Day4 直线上最多的点数 循环链表 四数相加2

Posted 2022-12-05 未来可期-2018

四数相加2
对下一个题的方式有启发，使用dict存储后两个之和

class Solution(object):
    def fourSumCount(self, A, B, C, D):
        Dict=
        for i in range(len(C)):
            for j in range(len(D)):
                if C[i]+D[j] in Dict:
                    Dict[C[i]+D[j]]+=1
                else:
                    Dict[C[i]+D[j]]=1
        global ans
        ans=0
        for i in range(len(A)):
            for j in range(len(B)):
                target=0-A[i]-B[j]
                if target in Dict:
                    ans+=Dict[target]
        return ans

直线上最多的点数
按照斜率区分不同的直线，注意需设一变量cnt记录在同一点的点的数量，以及斜率的精度问题

class Solution(object):
    def maxPoints(self, points):
        if not points:
            return 0
        elif len(points)==1:
            return 1
        Map=
        for i in range(len(points)):
            Map[i]=
            cnt=0
            for j in range(len(points)):
                if points[i][0]==points[j][0]:
                    # 在同一点
                    if points[i][1]==points[j][1]:
                        cnt+=1
                    # 在同一条垂直线上
                    else:
                        Map[i][1<<32+1]=Map[i].get(1<<32+1, 0)+1
                else:
                    k=7.0*(points[i][1]-points[j][1])/(points[i][0]-points[j][0])
                    Map[i][k]=Map[i].get(k,0)+1
            if len(Map[i])==0:
                Map[i][0.]=cnt
            else:
                for _ in Map[i].keys():
                    Map[i][_]+=cnt
        Max=0
        for k,v in Map.items():
            Max=max(Max, max(v.values()))
        return Max

循环链表
判断链表是否有环
l1每次走一格，l2每次走两格，如果链表中有环，则类似追击相遇问题，l2早晚会追到l1; 否则l2提前到末尾

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def hasCycle(self, head):
        l1=head
        l2=head
        while l2 and l2.next:
            l1=l1.next
            l2=l2.next.next
            if l1==l2:
                return True
        return False