LeetCode Prob.15 3Sum

先挖坑，补上几个大佬的代码

第一个代码，用的是双指针法，思想靠近于2Sum。

首先，对数组进行排序。

然后，对于以下三种情况，可以直接判断无解：

• 长度为0（其实可以说长度小于3）
• 最小数字大于0，即数组全大于0
• 最大数字小于0，即数组全小于0

接着我们对数组进行遍历。当我们选定了当前点，例如，nums[pt]，之后，就有了一个2Sum的目标：0 - nums[pt]

需要注意的是，由于遍历相当于将搜索空间从左边缩小，因此 10 行有个相应的判断条件。

现在我们要做的就是在left =  pt + 1 到 right = len(nums) - 1 之间，寻找2Sum的结果为 0 - nums[pt] 的二元组。

而且，这种寻找方式可以确保，pt, left, right 是单调上升的。

此外，在寻找到了结果之后，还并不能就此结束，因为在寻找到的 left 和 right 的内部还有可能出现满足的二元组。这也是 20 行到 23 行的意义。

并且，我们的寻找，已经找出了 pt + 1 到 len(nums) - 1 之间所有对应 0 - nums[pt]的二元组，所以我们可以在 11 行跳过同等的数字。

其它基本上就没有什么好说的了，如果2Sum的原理不懂可以去看看题目，很简单的。

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        #print (nums)
        #pre judging
        if len(nums) == 0 or nums[0] > 0 or nums[-1] < 0: return []
        ans = []
        pt = 0
        while pt < len(nums) - 2: #there must be 2 numbers ahead 
            if nums[pt] > 0: break
            if pt > 0 and nums[pt] == nums[pt - 1]:
                pt += 1
                continue
            left = pt + 1
            right = len(nums) - 1
            #print (nums[pt], nums[left], nums[right])
            while left < right:
                if nums[pt] + nums[left] + nums[right] == 0:
                    ans.append([nums[pt], nums[left], nums[right]])
                    while left < right and nums[left] == nums[left + 1]: left += 1
                    while left < right and nums[right] == nums[right - 1]: right -= 1
                    left += 1
                    right -= 1
                elif nums[pt] + nums[left] + nums[right] > 0:
                    right -= 1
                else:
                    left += 1
            pt += 1
        return ans 
            
            

class Solution:
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        d = {}
        for val in nums:
            d[val] = d.get(val, 0) + 1
        
        pos = [x for x in d if x > 0]
        neg = [x for x in d if x < 0]
        
        res = []
        if d.get(0, 0) > 2:
            res.append([0, 0, 0])
            
        for x in pos:
            for y in neg:
                s = -(x + y)
                if s in d:
                    if s == x and d[x] > 1:
                        res.append([x, x, y])
                    elif s == y and d[y] > 1:
                        res.append([x, y, y])
                    elif y < s < x:
                        res.append([x, y, s])
        return res

class Solution:
    def threeSum(self, nums: 'List[int]') -> 'List[List[int]]':
        from bisect import bisect_left, bisect_right
       
        target = 0
        
        result = []
        length = len(nums)
        
        if length < 3:
            return result
        
        count ={}
        # map the counts
        for n in nums:
            if n in count:
                count[n] += 1
            else:
                count[n] = 1
            
        keys = list(count.keys())
        keys.sort()
      
        t3 = target // 3
        if t3 in keys and count[t3] >= 3:
            result.append([t3, t3, t3])

        begin = bisect_left(keys, target - keys[-1] * 2)
        end = bisect_left(keys, target * 3)

        for i in range(begin, end):
            a = keys[i]
            if count[a] >= 2 and target - 2 * a in keys:
                result.append([a, a, target - 2 * a])

            max_b = (target - a) // 2  # target-a is remaining
            min_b = target - a - keys[-1]  # target-a is remaining and c can max be keys[-1]
            b_begin = max(i + 1, bisect_left(keys, min_b))
            b_end = bisect_right(keys, max_b)

            for j in range(b_begin, b_end):
                b = keys[j]
                c = target - a - b
                if c in count and b <= c:
                    if b < c or count[b] >= 2:
                        result.append([a, b, c])
        return result