twoSum & threeSum & fourSum

两数之和

leetcode 1：两数之和
难度等级：简单 ⭐

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

哈希表

不推荐使用暴力破解。

使用 hash 表，时间复杂度是 $O(n)$，空间复杂度也是 $O(n)$：

def twoSum(nums, target):
    dic = {}
    for i, num in enumerate(nums):
        if target-num in dic:
            return [dic[target-num], i]
        dic[num] = i

---

三数之和

leetcode 15：三数之和
难度等级：中等 ⭐⭐

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

双指针

双指针是一种效率很高的方法。

1. 对数组进行排序。
2. 遍历排序后数组：
   • 对于重复元素：跳过，避免出现重复解(去重)
   • 令左指针 $left=i+1$，右指针 $right=n-1$，当 $left<right$ 时，执行循环：
     • 若 $nums[i]+nums[left]+nums[right]$ 大于 $0$ 时，说明 $nums[right]$ 太大，$right$ 左移。
     • 若和小于 $0$，说明 $nums[left]$ 太小，$left$ 右移
     • 若和等于 $0$ 时，执行循环，判断左界和右界是否和下一位置重复，去除重复解。并同时将 $left$、$right$ 移到下一位置，寻找新的解。

def threeSum(self, nums: List[int]) -> List[List[int]]:
    nums.sort()
    res = []
    
    for i, num in enumerate(nums[:-2]):
        if i > 0 and num == nums[i-1]:  # 相同的元素跳过
            continue
            
        left, right = i + 1, len(nums) - 1
        while left < right:
            tmp = num + nums[left] + nums[right]
            if tmp > 0:
                right -= 1
            elif tmp < 0:
                left += 1
            else:
                res.append([num, nums[left], nums[right]])
                # 边界去重。left < right 是大前提，有此前提可避免重复扫描。
                # 若没有的话，left 遍历完一遍，right 可能要再遍历一遍，效率降低。
                while left < right and nums[right] == nums[right - 1]:
                    right -= 1
                while left < right and nums[left] == nums[left+1]:
                    left += 1
                left, right = left + 1, right - 1
    return res

时间复杂度为 $O(n)$。

改进

上面是一个三数之和实现，但观察会发现有许多不必要的计算，我们可以适当地使用 break 或 contiue 对循环加以控制。

数组有序排列，要求 target 为 0。那么遍历到 num 为正整数时就不必再继续下去了，因为后面的 left 和 right 所指向的数必定也为正整数，和肯定不为 0。

除此以外，还可以计算当前 num 的和最大值或最小值 与 target 进行比较，选择终止循环或结束本次循环。

改进后的代码如下：

def threeSum(self, nums: List[int]) -> List[List[int]]:
    nums.sort()
    res = []

    for i, num in enumerate(nums[:-2]):
        if num > 0:
            break
        if num + nums[i+1] + nums[i+2] > 0:  # “最小”的三个值大于 0，退出循环。
            break
        if num + nums[-1] + nums[-2] < 0:  # 若取的值与最大的值之和还是小于 0，说明选取的值要再大一些，跳过本次循环。
            continue
        if i > 0 and num == nums[i-1]:
            continue

        left, right = i + 1, len(nums) - 1
        while left < right:
            tmp = num + nums[left] + nums[right]
            if tmp > 0:
                right -= 1
            elif tmp < 0:
                left += 1
            else:
                res.append([num, nums[left], nums[right]])
                while left < right and nums[right] == nums[right - 1]:
                    right -= 1
                while left < right and nums[left] == nums[left+1]:
                    left += 1
                left, right = left + 1, right - 1
    return res

---

四数之和

leetcode 18：四数之和
难度等级：中等 ⭐⭐

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

双指针

使用三数之和双指针原理。这次要固定前面两个数，后两个数要用左右指针寻找。时间复杂度为 $O(n^3)$。

完整代码如下：

def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
    nums.sort()
    res = []
    n = len(nums)

    for i, num in enumerate(nums[:-3]):
        if num + nums[i+1] + nums[i+2] + nums[i+3] > target:  # “最小值”与 target 的比较
            break
        if num + nums[-1] + nums[-2] + nums[-3] < target:  # “最大值”与 target 的比较
            continue
        if i > 0 and num == nums[i-1]:  # 第一次去重
            continue

        for j in range(i+1, n-2):
            if num + nums[j] + nums[j+1] + nums[j+2] > target:
                break
            if num + nums[j] + nums[-1] + nums[-2] < target:
                continue
            if j > i+1 and nums[j] == nums[j-1]:  # 第二次去重，注意 j > i+1
                continue

            left, right = j+1, n - 1
            while left < right:
                tmp = num + nums[j] + nums[left] + nums[right]
                if tmp < target:
                    left += 1
                elif tmp > target:
                    right -= 1
                else:
                    res.append([num, nums[j], 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, right = left + 1, right - 1
    return res

注意：去除重复解，过滤重复条件。

参考

漫画：经典鹅厂面试题（4sum - nSum）
16 | 面试题：三数之和
排序 + 双指针，逐行解释