18.四数之和 python

四数之和

• 题目
• • 题目描述
  • [示例 1：](#示例 1：)
  • [示例 2：](#示例 2：)
  • 提示：
  • 题目链接
• 题解
• • [Python 实现](#Python 实现)
  • 解释
  • 提交结果

题目

题目描述

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

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

a、b、c 和 d 互不相同

numsa + numsb + numsc + numsd == 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

-10^9 <= numsi <= 10^9

-10^9 <= target <= 10^9

题目链接

四数之和

题解

要解决这个问题，可以使用类似于"三数之和"问题的双指针法，并在此基础上增加一层循环来处理四数之和。具体步骤如下：

1. 排序数组：首先对数组进行排序，这样可以方便地使用双指针法。
2. 固定两个数 ：遍历数组，固定两个数 nums[i] 和 nums[j]。
3. 使用双指针 ：对于固定的 nums[i] 和 nums[j]，使用两个指针 left 和 right 分别指向 j+1 和数组的末尾，寻找使四数之和等于 target 的组合。
4. 去重：在遍历过程中，跳过重复的元素，避免产生重复的四元组。

Python 实现

def fourSum(nums, target):
    nums.sort()  # 对数组进行排序
    n = len(nums)
    result = []
    
    for i in range(n):
        # 跳过重复的元素
        if i > 0 and nums[i] == nums[i - 1]:
            continue
        
        for j in range(i + 1, n):
            # 跳过重复的元素
            if j > i + 1 and nums[j] == nums[j - 1]:
                continue
            
            left, right = j + 1, n - 1
            while left < right:
                current_sum = nums[i] + nums[j] + nums[left] + nums[right]
                
                if current_sum < target:
                    left += 1  # 如果当前和小于目标值，移动左指针
                elif current_sum > target:
                    right -= 1  # 如果当前和大于目标值，移动右指针
                else:
                    result.append([nums[i], 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 += 1
                    right -= 1
    
    return result

解释

1. 排序数组：

   • nums.sort() 对数组进行排序，使得后续的双指针操作更加方便。

2. 固定两个数：

   • 使用两层 for 循环遍历数组，固定两个数 nums[i] 和 nums[j]。
   • 在每层循环中，跳过重复的元素，避免产生重复的四元组。

3. 使用双指针：

   • 初始化两个指针 left 和 right，分别指向 j+1 和数组的末尾。
   • 计算当前四数之和 current_sum。
   • 如果 current_sum 小于 target，移动左指针 left。
   • 如果 current_sum 大于 target，移动右指针 right。
   • 如果 current_sum 等于 target，将当前四元组添加到结果列表 result 中，并跳过重复的元素，避免产生重复的四元组。

4. 返回结果：

   • 遍历结束后，返回结果列表 result，包含所有满足条件且不重复的四元组。

通过这种方法，可以在 O(n^3) 的时间复杂度内解决问题，效率较高。

提交结果