leetCode#15. 3Sum

Description

Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

Note: The solution set must not contain duplicate triplets.

For example, given array S = [-1, 0, 1, 2, -1, -4],

A solution set is:
[
  [-1, 0, 1],
  [-1, -1, 2]
]

Code

class Solution(object):
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        res = []
        nums.sort()
        for i in xrange(len(nums)-2):
            if i > 0 and nums[i] == nums[i-1]:#重点，这里要使得I=0时能进下面的while。这个if的作用等同于当有一串相同的数时，只取第一个数。所以要放过i=0的情况，避免当一开始就有一串相同的数的时候，放过了第一个数。
                continue
            l, r = i+1, len(nums)-1
            while l < r:
                s = nums[i] + nums[l] + nums[r]
                if s < 0:
                    l +=1 
                elif s > 0:
                    r -= 1
                else:
                    res.append((nums[i], nums[l], nums[r]))
                    while l < r and nums[l] == nums[l+1]:
                        l += 1
                    while l < r and nums[r] == nums[r-1]:
                        r -= 1
                    l += 1; r -= 1
        return res

这道题没能写出来，上面是别人的代码。
自己理解了后写了一个：

class Solution(object):
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        nums.sort()
        res = []
        for i in xrange(len(nums) - 2):
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            l, r = i + 1, len(nums) - 1
            while l < r:
                cnt = nums[i] + nums[l] + nums[r]
                lPlus, rMinus = False, False
                if cnt < 0:
                    lPlus = True
                elif cnt > 0:
                    rMinus = True
                else:
                    res.append([nums[i], nums[l], nums[r]])
                    lPlus, rMinus = True, True
                if lPlus:
                    while l < r and nums[l] == nums[l + 1]:
                        l += 1
                    l += 1
                if rMinus:
                    while l < r and nums[r] == nums[r - 1]:
                        r -= 1
                    r -= 1
        return res

可惜超时了。就我的理解，我的代码逻辑和上面代码逻辑一样，之所以会超时，是因为我的代码中if和while更多，需要更多的时间。而我的代码中之所以多了些if和while是为了应对某种类型的测试用例。结果刚好测试用例不是这种类型的，因此我的时间超时了。但是，同理，假如测试用例不是上面代码应对的那种，那么它的代码也会超时。实际上，上面的代码提交后，速度的确也只beat了15%，连中间值都没达到。
更改自己的代码成上面的样式后，果然是过了。看了下评论区，似乎这题最佳算法只能到N*2的程度了。
下面这个是另一种实现方式：

def three_sum(nums):
    nums.sort()
    solution = []
    for idx,tgt in enumerate(nums):
        if idx>0 and nums[idx] == nums[idx-1]:
            continue
        path = {}
        vist = set()
        for i in xrange(idx+1,len(nums)):
            if nums[i] not in path:
                path[-tgt-nums[i]] = nums[i]
            elif nums[i] in path and nums[i] not in vist:
                solution.append([tgt,path[nums[i]],nums[i]])
                vist.add(nums[i])
    return solution

看起来更简洁些，另一种实现方式吧。不过速度也不快。

Conclusion

下面放上该题最佳只能N*2的依据，评论区大佬给的

No, you can’t. If you’re interested, here is a paper that proves a lower bound of Ω(n^ceil(k/2)) for the k-SUM problem (deciding whether k numbers out of n sums to 0) where ceil is the ceiling function. Here k=3, so you cannot do better than Ω(n^2).

Fun fact, there exist better quantum algorithms. The quantum complexity of k-SUM is Θ(n^(k/(k+1)) which is sub-linear! How cool is that? (Here is the paper describing the algorithm, and here the proof of optimality)