Leecode15——三数之和（双指针）

Leecode 2024.3.16

5.三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]

输出：[[-1,-1,2],[-1,0,1]]

解释：

nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。

nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。

nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。

不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。

注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]

输出：[]

解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]

输出：[[0,0,0]]

解释：唯一可能的三元组和为 0 。

提示：

3 <= nums.length <= 3000

-105 <= nums[i] <= 105

---

个人解答

思路：

最简单的办法，使用枚举，三个数三个循环，但是根据我们之前的思路，可以把一个最内层的循环变为一次查询，由此确定了算法的大框架。

但是本题还有个难点，就是重复：1.列出的三元组元素在nums中不能重复；2.最后输出的list中的三元组乱序可以，但是不能重复。

根据上面提到的，写出了第一版的解答：

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        output = []
        for i,target in enumerate(nums):
            for j,data1 in enumerate(nums):
                data2 = -target-data1
                if i == j:
                    continue
                if data2 in nums:
                    if j!=nums.index(data2) and i!=nums.index(data2):
                        sum_list = sorted([target, data1, data2])
                        if sum_list not in output:
                            output.append(sum_list)
        return output

显然超时了，下面来优化代码和逻辑。

---

排序加双指针

由于每次排序的复杂度都很高，所以不太敢上来就用，但是这个题，排序还是能提速很多的，而且会便于双指针的动作。所以先对nums排序。

这里可能会有人对nums做去重的操作，但是这个操作在这道题，影响极大，举两个例子就知道了，所以万万不可。

现在我们把后面两次的循环用双指针来实现，那么这里就需要思考两个指针的基本逻辑了：

左边指针从最小负数开始，当三数之和小于0时，就需要右移；

右边指针从最大正数开始，当三数之和大于0时，就需要左移。

当和等于0时，判断下标和数组是否重复，加入output即可。

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums = sorted(nums)
        output=[]
        for i,data1 in enumerate(nums):
            # 如果data1大于0了，那么都为正数的就不可能
            left = 0 
            right = len(nums)-1
            target = -data1
            while (left<right):
                if nums[left]+nums[right]<target:
                    left = left+1
                elif nums[left]+nums[right]>target:
                    right = right-1
                elif nums[left]+nums[right]==target:
                    if i!=left and i!=right:
                        list_in = sorted([data1, nums[left], nums[right]])
                        if list_in not in output:
                            output.append(list_in)
                    left += 1
                    right -= 1
        return output

---

结果还是超时了，那就是需要做一些很骚的改进了。

（注入先验）

1.这里改进的关键在于左指针的位置，其实第一层循环搜索过的nums里的数据，就不需要再遍历了，因此需要把left设置为i+1。

2.这样其实限制了三个指针对应数值的大小关系：nums[i]<nums[left]<nums[right]，那么根据这个大小关系，我们可以手动过滤很多查询：

（1）nums[i]如何大于了0，那么三数之和必然不可能为0，直接返回结果就可以。这样我们可以在最外层去掉很多循环次数；

            if data1 > 0:
                return output

（2）考虑数组中有两个相同的数字，显然查询过第一个数字后，第二个数字就不需要再查询了

            if(i>0 and nums[i]==nums[i-1]):
                continue

（3）同时，这里因为三个数字已经排序了，就不需要在把三元组插入output时进行排序。

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums = sorted(nums)
        output=[]
        for i,data1 in enumerate(nums):
            # 如果data1大于0了，那么都为正数的就不可能
            if data1 > 0:
                return output
            if(i>0 and nums[i]==nums[i-1]):
                continue
            # 修改左指针位置
            left = i+1 
            right = len(nums)-1
            target = -data1
            while (left<right):
                sums = nums[left]+nums[right]
                if sums<target:
                    left = left+1
                elif sums>target:
                    right = right-1
                elif sums==target:
                    list_in = [data1, nums[left], nums[right]]
                    if list_in not in output:
                        output.append(list_in)
                    left += 1
                    right -= 1
        return output

不过遗憾的是，加了这些骚操作，代码还是没有过，依旧是超时。那看来，这个题就还需要引入更多的先验了，个人优化到上面这个代码实在优化不动了，就看了一下题解。

---

官方题解

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        n = len(nums)
        nums.sort()
        ans = list()
        
        # 枚举 a
        for first in range(n):
            # 需要和上一次枚举的数不相同
            if first > 0 and nums[first] == nums[first - 1]:
                continue
            # c 对应的指针初始指向数组的最右端
            third = n - 1
            target = -nums[first]
            # 枚举 b
            for second in range(first + 1, n):
                # 需要和上一次枚举的数不相同
                if second > first + 1 and nums[second] == nums[second - 1]:
                    continue
                # 需要保证 b 的指针在 c 的指针的左侧
                while second < third and nums[second] + nums[third] > target:
                    third -= 1
                # 如果指针重合，随着 b 后续的增加
                # 就不会有满足 a+b+c=0 并且 b<c 的 c 了，可以退出循环
                if second == third:
                    break
                if nums[second] + nums[third] == target:
                    ans.append([nums[first], nums[second], nums[third]])
        
        return ans

其实也就只是把上面提到的优化（2）也用在了下面left和right的移动上，大体思路已经找对了。

---

总结

1.这个题初看是有点像两数之和的，不过是把两次循环升维到了三层循环；

2.降低三层循环复杂度的办法，如这里的双指针、哈希表等（不知道这里能不能用哈希表）优化；

3.双指针的动作方式需要巧妙设计，引入人为的判断能加速算法；

4.有的时候，对数组适当的预处理（排序、去重）也很重要，能简化算法逻辑。