问题描述

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n

a、b、c 和 d 互不相同

nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

示例1

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

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

示例2

输入：nums = [2,2,2,2,2], target = 8

输出：[[2,2,2,2]]

提示

• 1 <= nums.length <= 200
• -109 <= nums[i] <= 109
• -109 <= target <= 109

思路分析

对于这个问题，我们可以使用双指针的方法来解决

1. 首先对数组进行排序，这样可以方便后续的去重和判断。
2. 然后使用两层循环来确定第一和第二个数的位置，遍历数组中的每一对数（nums[a]和nums[b]）。
3. 对于每一对数，使用双指针的方法在剩下的子数组中搜索剩下的两个数（nums[c]和nums[d]）。
4. 使用一个左指针和一个右指针，分别指向剩下的子数组的起始位置和末尾位置。
5. 在左指针小于右指针的条件下，计算当前四个数的和 sum = nums[a] + nums[b] + nums[c] + nums[d]。
6. 如果 sum 等于 target，则将这四个数加入结果集。
7. 如果 sum 小于 target，则说明当前和太小，需要增大和，因此将左指针向右移动一位。
8. 如果 sum 大于 target，则说明当前和太大，需要减小和，因此将右指针向左移动一位。
9. 在移动指针的过程中，需要注意忽略重复的解，即去掉相邻重复的元素。
10. 继续移动指针直到左指针大于等于右指针时结束，表示已经搜索完所有可能的四元组。
11. 继续遍历剩下的两个数，即固定下一对数，重复上述步骤。
12. 最终返回所有满足条件的四元组。
    这样就可以找到满足条件且不重复的四元组了。

代码分析

• 第1行，我们定义了一个Solution类来解决问题。
  
• 第2行，fourSum方法接收两个参数：nums表示输入的数组，target表示目标和。
  
• 第3行，获取数组nums的长度，并进行判断。如果数组长度小于4，直接返回空列表[]，因为至少需要四个元素才能形成一个四元组。
  
• 第4行，对数组进行排序，这是为了方便后续的去重和判断。
  
• 第5行，初始化结果列表res为空。
  
• 第6行，外层循环遍历数组中所有可能的第一个数的位置，即下标a从0到n-3。
  
• 第7行，使用条件判断，如果a大于0且当前元素nums[a]与前一个元素相同，说明这个数字已经被考虑过了，应该跳过，进入下一次循环。
  
• 第8行，内层循环遍历剩下的子数组中所有可能的第二个数的位置，即下标b从a+1到n-2。
  
• 第9行，使用条件判断，如果b大于a+1且当前元素nums[b]与前一个元素相同，说明这个数字已经被考虑过了，应该跳过，进入下一次循环。
  
• 第10行，初始化左指针left为b+1，即剩下子数组中的起始位置。
  
• 第11行，初始化右指针right为n-1，即剩下子数组中的末尾位置。
  
• 第12行，进入双指针的搜索循环，判断左指针是否小于右指针。
  
• 第13行，计算当前四个数的和 sum = nums[a] + nums[b] + nums[left] + nums[right]。
  
• 第14行，如果和等于目标和target，说明找到了一个满足条件的四元组。将这四个数加入结果列表res中。
  
• 第15行，进入内层循环，进行去重处理。如果左指针小于右指针且当前左指针所指的元素与下一个元素相同，则将左指针向右移动一位，跳过重复的元素。
  
• 第16行，进入内层循环，进行去重处理。如果左指针小于右指针且当前右指针所指的元素与前一个元素相同，则将右指针向左移动一位，跳过重复的元素。
  
• 第17行，左指针向右移动一位。
  
• 第18行，右指针向左移动一位。
  
• 第19行，内层循环结束。
  
• 第20行，外层循环继续遍历剩下的可能的第二个数。
  
• 第21行，外层循环结束。
  
• 第22行，返回结果列表res。
  

这样就完成了对四数之和的求解。

完整代码

class Solution:
    def fourSum(self, nums, target):
        n = len(nums)
        # 判断数组长度是否小于4
        if n < 4:
            return []
        # 对数组进行排序
        nums.sort()
        res = []  # 结果列表
        # 外层循环遍历所有可能的第一个数的位置
        for a in range(n-3):
            # 对重复元素进行去重
            if a > 0 and nums[a] == nums[a-1]:
                continue
            # 内层循环遍历剩下的子数组中所有可能的第二个数的位置
            for b in range(a+1, n-2):
                # 对重复元素进行去重
                if b > a+1 and nums[b] == nums[b-1]:
                    continue
                left = b + 1  # 左指针
                right = n - 1  # 右指针
                # 双指针搜索循环
                while left < right:
                    # 计算当前四个数的和
                    sum = nums[a] + nums[b] + nums[left] + nums[right]
                    if sum == target:  # 和等于目标和
                        res.append([nums[a], nums[b], 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 sum < target:  # 和小于目标和
                        left += 1
                    else:  # 和大于目标和
                        right -= 1
        return res

详细分析

• n = len(nums)：获取数组 nums 的长度，即元素个数。
• if n < 4: return []：如果数组长度小于4，直接返回空列表，因为无法找到四个数的组合。
• nums.sort()：对数组进行排序，以确保相同的数字在一起，便于后续的去重操作。
• res = []：定义一个结果列表，用于存储满足条件的四个数的组合。
• 外层循环 for a in range(n-3):：遍历可能的第一个数的位置，范围是从第0个到倒数第4个数。
• if a > 0 and nums[a] == nums[a-1]: continue：去除重复的第一个数，如果当前数与前一个数相等，则跳过本次循环。
• 内层循环 for b in range(a+1, n-2):：遍历剩下的子数组中所有可能的第二个数的位置。
• if b > a+1 and nums[b] == nums[b-1]: continue：去除重复的第二个数，如果当前数与前一个数相等，则跳过本次循环。
• left = b + 1：初始化左指针指向剩余子数组的起始位置。
• right = n - 1：初始化右指针指向剩余子数组的末尾位置。
• 双指针搜索循环 while left < right:：不断移动左右指针以搜索四个数的组合。
• sum = nums[a] + nums[b] + nums[left] + nums[right]：计算当前四个数的和。
• if sum == target:：如果和等于目标值，表示找到了一个满足条件的组合。

• 将四个数加入结果列表中：res.append([nums[a], nums[b], nums[left], nums[right]])。
• 内层循环进行去重处理，跳过重复的元素。
• 左指针向右移动一位：left += 1。
• 右指针向左移动一位：right -= 1。

• elif sum < target:：如果和小于目标值，说明需要增大和，左指针向右移动一位：left += 1。
• else:：如果和大于目标值，说明需要减小和，右指针向左移动一位：right -= 1。
• 最后返回结果列表 res，其中存储了所有满足条件的四个数的组合。

运行效果截图

调用示例

solution = Solution()
nums = [1,0,-1,0,-2,2]
target = 0
nums1 = [2,2,2,2,2]
target1 = 8
print(solution.fourSum(nums, target))
print(solution.fourSum(nums1, target1))

运行结果

完结