[LeetCode] (medium) 18. 4Sum_18 4sum dfs-优快云博客

本文深入探讨了LeetCode上四数之和问题的解决策略，通过递归和循环两种方法详细讲解了如何找到数组中四个元素相加等于目标值的所有唯一组合。文章对比了双指针技巧在2数之和问题上的应用，并介绍了如何通过剪枝提高4数之和问题的解决效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given an array nums of n integers and an integer target, are there elements a, b, c, and d in nums such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.

Note:

The solution set must not contain duplicate quadruplets.

Example:
Given array nums = [1, 0, -1, 0, -2, 2], and target = 0.

A solution set is:
[
  [-1,  0, 0, 1],
  [-2, -1, 1, 2],
  [-2,  0, 0, 2]
]

参考： https://blog.youkuaiyun.com/JackZhang_123/article/details/77747890

归根结底是要将情况归结到2sum的问题，然后利用双指针进行寻找。

由于是4sum，数字较少，所以可以使用循环来实现，其中加入剪枝可以增加效率。但是我如参考的博文那样使用了递归实现，可以直接扩展到ksum的情况，虽然效率较低，但扩展性强。

class Solution {
public:
    vector<vector<int>> result;
    
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        vector<int> inter_result;
        dfs(nums, inter_result, 4, target, 0, nums.size()-1);
        return result;
    }
    
    void dfs(vector<int> &nums, vector<int> &inter_result, int k, int target, int lo, int hi){
        if(k == 2){   //2sum，可用双指针求解，递归终止
            // int sum = accumulate(inter_result.begin(), inter_result.end(), 0);
            int st = lo;
            int ed = hi;
            while(st < ed){
                int cur = nums[st]+nums[ed];
                if(cur == target){
                    vector<int> tem = inter_result;
                    tem.push_back(nums[st]);
                    tem.push_back(nums[ed]);
                    result.push_back(tem);
                    do{
                        ++st;
                    }while(st < ed && nums[st] == nums[st-1]);
                    do{
                        --ed;
                    }while(st < ed && nums[ed] == nums[ed+1]);
                }else if(cur > target){
                    do{
                        --ed;
                    }while(st < ed && nums[ed] == nums[ed+1]);
                }else{
                    do{
                        ++st;
                    }while(st < ed && nums[st] == nums[st-1]);
                }
            }
        }else{
            for(int i = lo; i <= hi-k+1; ++i){
                if(i != lo && nums[i] == nums[i-1]) continue;
                inter_result.push_back(nums[i]);
                dfs(nums, inter_result, k-1, target-nums[i], i+1, hi);
                inter_result.pop_back();
            }
        }
    }
};

使用循环的高效代码：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        int n=nums.size();
        if(n<=3) return res;
        sort(nums.begin(), nums.end());
        for(int i=0;i<n-3;i++)
        {
            if(i>0 && nums[i]==nums[i-1]) continue; 
            if(nums[i]+nums[i+1]+nums[i+2]+nums[i+3] > target) break;    //这两行都是剪枝
            if(nums[i]+nums[n-1]+nums[n-2]+nums[n-3] < target) continue;
 
            for(int j=i+1;j<n-2;j++)
            {
                if(j>i+1 && nums[j]==nums[j-1]) continue;
                if(nums[i]+nums[j]+nums[j+1]+nums[j+2] > target) break;
                if(nums[i]+nums[j]+nums[n-1]+nums[n-2] < target) continue;
                int left = j+1, right = n-1;
                
                while(left <right)
                {
                    int val = nums[i]+nums[j]+nums[left]+nums[right];
                    if(val < target)
                    {
                        left++;
                    }
                    else if(val>target)
                    {
                        right--;
                    }
                    else
                    {
                        res.push_back({nums[i],nums[j], nums[left], nums[right]});
                        do{left++;} while(nums[left] ==nums[left-1] && left<right);
                        do{right--;} while(nums[right] == nums[right+1]&&left<right);
                    }
                }
            }
        }
        return res;
    }
};