Leetcode 4sum

初始思路想基于3sum写4sum 复杂度是$o(N^3)$,于是尝试有没有更简单的算法

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        sum_l={}
        for i in range(len(nums)):                                #[1]
            for j in range(i+1,len(nums)):
                sum_label=nums[i]+nums[j]
                if sum_label not in sum_l:
                    sum_l[sum_label]=[]
                sum_l[sum_label].append([i, j])
        answer=set()
        dict_42={}
        fanswer=list()
        for a in sum_l:                                           #[2]
            if a not in dict_42:                                  #此处先做不在词典的判断，可以把a=target/2的特殊情况考虑进去，而不需要加判断
                dict_42[target-a]=sum_l[a]
            if a in dict_42:
                for aff1 in range(len(sum_l[a])):                 #[3]
                    for aff2 in range(len(dict_42[a])):
                        a1,a2 = sum_l[a][aff1]
                        b1,b2 = dict_42[a][aff2]
                        items =set([a1,a2,b1,b2])
                        if len(items)==4 :                        #这个地方先使用set，可以把相同元素去掉，set的元素可以是tuple的，但不能是list的，因为list是unhashable的
                            newItem=[nums[fi] for fi in items]
                            newItem=tuple(sorted(newItem))
                            answer.add(newItem);

        for a in answer:                                          #转化成list输出
            aff=[i for i in a]
            fanswer.append(aff)
        return fanswer
             

算法中[1],[2]处循环是$o(N^2)$的，在2处是$o(N^2)$时，3处两个循环都是$o(1)$的，所以整体是$o(N^2)$的
极端情况下[2]处循环是$o(1)$时，[3]处两循环可能都是$o(N^2)$的，所以整体式$o(N^4)$的，同理[2]处是$o(N)$时，整体有可能是$o(N^3)$的，但是在更一般的情况下，该算法有更好的复杂度。