[leetcode] 【数组】18. 4Sum_cpp vector second.size-优快云博客

本文探讨了如何在数组中寻找四个整数的组合，使它们的和等于给定的目标值。采用排序、缓存等策略减少搜索空间，避免重复解。通过C++实现并附带详细的代码解释。

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

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

Note:
Elements in a quadruplet (a,b,c,d) must be in non-descending order. (ie, a ≤ b ≤ c ≤ d)
The solution set must not contain duplicate quadruplets.
For example, given array S = {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)

题解

在数组中找到所有4个元素的组合，组合之和为target。组合按顺序排好，并且不能重复。
a遍历4遍
b排序+夹逼
因为是4个元素，所以先存储所有2个元素组成的组合。
存储方法有两种:

unordered_multimap

可以用multimap存储重复的key，不同的pair。
这里介绍equal_range来遍历同一个key的所有pair：

unordered_multimap<int,pair<int,int> >>
auto range = cache.equal_range(key);
for (auto j = range.first; j != range.second; ++j)

nordered_multimap
同一个key，一系列pair。
这里遍历所有pair就简单了，

unordered_map<int,vector<pair<int,int> > >
auto point2=cache.find(key);
for(int i=0;i!=point2->second.size();i++)

最后需要注意的就是防止重复的操作出现，要不然容易超时。
我的代码里有两个地方做了重复过滤，读者请自行理解为何需要过滤。

//cpp
class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int> > res;
        if(nums.size()<4)
            return res;
        sort(nums.begin(),nums.end());
        unordered_map<int,vector<pair<int,int> > > cache;//记录每种组合
        for(int i=0;i!=nums.size();)
        {
            for(int j=i+1;j!=nums.size();)
            {
                cache[nums[i]+nums[j]].push_back(make_pair(nums[i],nums[j]));
                j++;
                while(nums[j-1]==nums[j]&&j!=nums.size()) j++;
            }
            i++;
            while(nums[i-1]==nums[i]&&i!=nums.size()) i++;
        }
        unordered_map<int,int> count;//记录每个数出现的次数
        for(int i=0;i!=nums.size();i++)
            count[nums[i]]++;
        for(auto point1 = cache.begin(); point1 != cache.end(); ++point1)
        {
            int key=target-point1->first;
            auto point2=cache.find(key);
            if(point2!=cache.end())
            {
                if(point1->first > point2->first) continue;//重复过滤
                for(int i=0;i!=point1->second.size();i++)//第一组大小的每种组合
                {
                    for(int j=0;j!=point2->second.size();j++)//第二组大小的每种组合
                    {
                        auto a=point1->second[i].first;
                        auto b=point1->second[i].second;
                        auto c=point2->second[j].first;
                        auto d=point2->second[j].second;
                        if(max(a,b)<=min(c,d)) //重复过滤
                        {
                            count[a]--;
                            count[b]--;
                            count[c]--;
                            count[d]--;
                            if(count[a]>=0&&count[b]>=0&&count[c]>=0&&count[d]>=0)//当两种组合一样时，这样可进行区分是否合法
                            {
                                vector<int> temp={a,b,c,d};
                                sort(temp.begin(),temp.end());
                                res.push_back(temp);
                            }
                            count[a]++;
                            count[b]++;
                            count[c]++;
                            count[d]++;
                        }
                    }
                }
            }
        }
        return res;
    }
};