LeetCode 第18题：四数之和

合集 - 算法笔记(41)
1.LeetCode 第10题：正则表达式匹配2.LeetCode 第1题：两数之和3.LeetCode 第2题：两数相加4.LeetCode 第3题：无重复字符的最长子串5.LeetCode 第4题：寻找两个正序数组的中位数6.LeetCode 第8题：字符串转换整数 (atoi)7.LeetCode 第7题：整数反转8.LeetCode 第6题：Z字形变换9.LeetCode 第5题：最长回文子串10.LeetCode 第9题：回文数11.LeetCode 第11题：盛最多水的容器12.LeetCode 第12题：整数转罗马数字13.LeetCode 第13题：罗马数字转整数14.LeetCode 第14题：最长公共前缀15.LeetCode 第15题：三数之和16.LeetCode 第16题：最接近的三数之和17.LeetCode 第17题：电话号码的字母组合
18.LeetCode 第18题：四数之和
19.LeetCode 第19题：删除链表的倒数第N个结点20.LeetCode 第20题：有效的括号21.LeetCode 第21题：合并两个有序链表22.LeetCode 第22题：括号生成23.LeetCode 第23题：合并K个升序链表24.LeetCode 第24题：两两交换链表中的节点25.LeetCode 第25题：K 个一组翻转链表26.LeetCode 第26题：删除有序数组中的重复项27.LeetCode 第27题：移除元素28.LeetCode 第28题：找出字符串中第一个匹配项的下标29.LeetCode 第29题：两数相除30.LeetCode 第30题：串联所有单词的子串31.LeetCode 第31题：下一个排列32.LeetCode 第32题：最长有效括号33.LeetCode 第33题：搜索旋转排序数组34.LeetCode 第34题：在排序数组中查找元素的第一个和最后一个位置35.LeetCode 第35题：搜索插入位置36.LeetCode 第36题：有效的数独37.LeetCode 第37题：解数独38.LeetCode 第38题：外观数列39.LeetCode 第39题：组合总和40.LeetCode 第40题：组合总和 II41.LeetCode 第41题：缺失的第一个正数
收起

LeetCode 第18题：四数之和

题目描述

给你一个由 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

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

难度

中等

题目链接

https://leetcode.cn/problems/4sum/

示例

示例 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. 使用两层循环固定前两个数
  3. 使用双指针寻找后两个数
  4. 注意去重处理
  5. 注意整数溢出问题

具体步骤：

  1. 对数组进行排序
  2. 第一层循环固定第一个数
  3. 第二层循环固定第二个数
  4. 使用双指针寻找剩余两个数
  5. 根据四数之和与target的关系移动指针
  6. 注意各层的去重处理

时间复杂度：O(n³)
空间复杂度：O(1)，不考虑返回值的空间

代码实现

C# 实现

public class Solution {
    public IList<IList<int>> FourSum(int[] nums, int target) {
        List<IList<int>> result = new List<IList<int>>();
        if (nums == null || nums.Length < 4) {
            return result;
        }
      
        Array.Sort(nums);
        int n = nums.Length;
      
        // 固定第一个数
        for (int i = 0; i < n - 3; i++) {
            // 去重
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
          
            // 剪枝：当前最小和大于target，后面的组合一定更大
            if ((long)nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) {
                break;
            }
          
            // 剪枝：当前最大和小于target，当前i的组合不可能是解
            if ((long)nums[i] + nums[n - 3] + nums[n - 2] + nums[n - 1] < target) {
                continue;
            }
          
            // 固定第二个数
            for (int j = i + 1; j < n - 2; j++) {
                // 去重
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }
              
                // 剪枝：当前最小和大于target
                if ((long)nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) {
                    break;
                }
              
                // 剪枝：当前最大和小于target
                if ((long)nums[i] + nums[j] + nums[n - 2] + nums[n - 1] < target) {
                    continue;
                }
              
                // 使用双指针寻找剩余两个数
                int left = j + 1;
                int right = n - 1;
              
                while (left < right) {
                    long sum = (long)nums[i] + nums[j] + nums[left] + nums[right];
                  
                    if (sum == target) {
                        result.Add(new List<int> { nums[i], nums[j], nums[left], nums[right] });
                      
                        // 去重
                        while (left < right && nums[left] == nums[left + 1]) {
                            left++;
                        }
                        while (left < right && nums[right] == nums[right - 1]) {
                            right--;
                        }
                      
                        left++;
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        right--;
                    }
                }
            }
        }
      
        return result;
    }
}

优化版本（添加更多剪枝）

public class Solution {
    public IList<IList<int>> FourSum(int[] nums, int target) {
        List<IList<int>> result = new List<IList<int>>();
        if (nums == null || nums.Length < 4) {
            return result;
        }
      
        Array.Sort(nums);
        int n = nums.Length;
      
        // 预先计算一些边界值
        long minSum = (long)nums[0] + nums[1] + nums[2] + nums[3];
        long maxSum = (long)nums[n-1] + nums[n-2] + nums[n-3] + nums[n-4];
      
        // 如果target在可能范围之外，直接返回
        if (target < minSum || target > maxSum) {
            return result;
        }
      
        for (int i = 0; i < n - 3; i++) {
            // 去重
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
          
            // 计算当前i的最小和最大可能值
            long minCurrent = (long)nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3];
            long maxCurrent = (long)nums[i] + nums[n - 1] + nums[n - 2] + nums[n - 3];
          
            // 剪枝
            if (target < minCurrent) break;
            if (target > maxCurrent) continue;
          
            for (int j = i + 1; j < n - 2; j++) {
                // 去重
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }
              
                // 计算当前j的最小和最大可能值
                long minJ = (long)nums[i] + nums[j] + nums[j + 1] + nums[j + 2];
                long maxJ = (long)nums[i] + nums[j] + nums[n - 1] + nums[n - 2];
              
                // 剪枝
                if (target < minJ) break;
                if (target > maxJ) continue;
              
                int left = j + 1;
                int right = n - 1;
              
                while (left < right) {
                    long sum = (long)nums[i] + nums[j] + nums[left] + nums[right];
                  
                    if (sum == target) {
                        result.Add(new List<int> { nums[i], nums[j], nums[left], nums[right] });
                      
                        // 去重
                        while (left < right && nums[left] == nums[left + 1]) left++;
                        while (left < right && nums[right] == nums[right - 1]) right--;
                      
                        left++;
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        right--;
                    }
                }
            }
        }
      
        return result;
    }
}

代码详解

基本版本：

  1. 排序和初始化：
    • 对数组排序，便于去重和使用双指针
    • 处理特殊情况（数组长度小于4）
  2. 双层循环：
    • 固定前两个数
    • 使用双指针寻找后两个数
  3. 去重处理：
    • 每一层都需要去重
    • 使用while循环跳过重复元素
  4. 整数溢出：
    • 使用long类型处理和的计算

优化版本：

  1. 预处理：
    • 计算整个数组可能的最小和最大和
    • 提前判断target是否在可能范围内
  2. 更多剪枝：
    • 计算每一层的最小和最大可能值
    • 根据target的大小提前结束或跳过
  3. 性能优化：
    • 减少不必要的计算
    • 提前结束不可能的分支

执行结果

基本版本：

  • 执行用时：128 ms
  • 内存消耗：42.8 MB

优化版本：

  • 执行用时：116 ms
  • 内存消耗：42.5 MB

总结与反思

  1. 这道题的关键点：
    • 理解三数之和到四数之和的扩展
    • 处理整数溢出问题
    • 高效的剪枝策略
  2. 优化策略：
    • 添加更多的剪枝条件
    • 预处理边界情况
    • 避免重复计算
  3. 注意事项：
    • 整数溢出的处理
    • 去重的正确性
    • 边界条件的处理

相关题目

posted @   旧厂街小江  阅读(10)  评论(0)  编辑  收藏  举报
相关博文：
· LeetCode 第15题：三数之和
· LeetCode 第16题：最接近的三数之和
· Leetcode18. 四数之和
· 刷刷刷Day7| 18. 四数之和
· LeetCode18 四数之和
阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· DeepSeek 开源周回顾「GitHub 热点速览」
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
点击右上角即可分享
微信分享提示