[C++]LeetCode: 71 4Sum && kSum总结

最新推荐文章于 2022-11-25 14:32:38 发布

Cindy_niu

最新推荐文章于 2022-11-25 14:32:38 发布

阅读量2.9k

点赞数

本文链接：https://blog.csdn.net/cinderella_niu/article/details/42455523

版权

LeetCode 专栏收录该内容

132 篇文章 1 订阅

订阅专栏

题目：

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)

Answer 1: 通用法退化到2Sum问题

有篇博客详细描述了kSum问题：Summary for LeetCode 2Sum, 3Sum, 4Sum, K Sum

K Sum总结：

K Sum问题描述：给你一组N个数字(比如 vector<int> num), 然后给你一个常数(比如 int target) ，我们的goal是在这一堆数里面找到K个数字，使得这K个数字的和等于target。

注意事项：

1.去除重复项。

注意这一组数字可能有重复项：比如 1 1 2 3 , 求3sum, 然后 target = 6, 你搜的时候可能会得到两组1 2 3, 1 2 3，1 来自第一个1或者第二个1, 但是结果其实只有一组，所以最后结果要去重。

2.注意退化过程中，确定前k-2个数字时所取的范围。

比如3Sum问题，第一个数的范围是0~num.size()-2. 因为我们排好序以后, 只需要检测到倒数第三个数字就行了, 因为剩下的只有一种triplet 由最后三个数字组成. 其他k sum问题类似确定范围。

解决方法：先排序后夹逼，将K Sum问题退化为 k-1 Sum问题，最终退化到2Sum问题。然后利用头尾指针找到两个数使得他们的和等于新的target.

给出2 Sum的核心代码：

<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">//2 sum
int i = starting; //头指针
int j = num.size() - 1; //尾指针

while(i < j) {
    int sum = num[i] + num[j];

    if(sum == target) {
        store num[i] and num[j] somewhere;
        if(we need only one such pair of numbers)
            break;
        otherwise
            do ++i, --j;
    }
    else if(sum < target)
        ++i;
    else
        --j;
}<strong>
</strong></span></span></span>

2sum的算法复杂度是O(N log N) 因为排序用了N log N以及头尾指针的搜索是线性的，所以总体是O(N log N)，好了现在考虑3sum, 有了2sum其实3sum就不难了，这样想：先取出一个数，那么我只要在剩下的数字里面找到两个数字使得他们的和等于(target – 那个取出的数)就可以了吧。所以3sum就退化成了2sum, 取出一个数字，这样的数字有N个，所以3sum的算法复杂度就是O(N^2 ), 注意这里复杂度是N平方，因为你排序只需要排一次，后面的工作都是取出一个数字，然后找剩下的两个数字，找两个数字是2sum用头尾指针线性扫，这里很容易错误的将复杂度算成O(N^2 log N)，这个是不对的。我们继续的话4sum也就可以退化成3sum问题(copyright @sigmainfy)，那么以此类推，K-sum一步一步退化，最后也就是解决一个2sum的问题，K sum的复杂度是O(n^(K-1))。这个界好像是最好的界了，也就是K-sum问题最好也就能做到O(n^(K-1))复杂度，之前有看到过有人说可以严格数学证明，这里就不深入研究了。
AC Code: (4 Sum)

注意点：注意第一数和第二个数确定的起止范围。

<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<vector<int>> ret;
        if(num.size() < 4) return ret;
        int n = num.size();
        vector<int> ivec(num);
        sort(ivec.begin(), ivec.end());
        
        for(int i = 0; i < n - 3;i++)   //(1) trick 1 确定范围到倒数第四个数
        {
            if(i > 0 && ivec[i] == ivec[i-1]) continue;  //防止第一个数字重复  （2）trick 2 避免重复项
            for(int j = i+1; j < n - 2;j++)
            {
                if(j > i + 1 && ivec[j] == ivec[j-1]) continue;  //防止第二个数字重复
                int newtarget = target - ivec[i] - ivec[j];
                int k = j + 1;
                int l = n - 1;
                
                while(k < l)
                {
                    if(ivec[k] + ivec[l] == newtarget)
                    {
                        vector<int> tmp{ivec[i], ivec[j], ivec[k], ivec[l]};
                        ret.push_back(tmp);                    //trick 3 跳过重复项
                        do{
                            k++;
                        }while(k < l && ivec[k] == ivec[k-1]);
                        do{
                            l--;
                        }while(k < l && ivec[l] == ivec[l+1]);
                    }
                    else if(ivec[k] + ivec[l] > newtarget)
                    {
                        l--;
                    }
                    else
                    {
                        k++;
                    }
                }
            }
        }
        
        return ret;
    }
};</span></span></span>

Answer 2 : Hash法

思路：O（n^2）的算法，和前面相当，都是先对数组排序。我们先枚举出所有二个数的和存放在哈希map中，其中map的key对应的是二个数的和，因为多对元素求和可能是相同的值，故哈希map的value是一个链表（下面的代码中用数组代替），链表每个节点存的是这两个数在数组的下标；这个预处理的时间复杂度是O（n^2）。接着和算法1类似，枚举第一个和第二个元素，假设分别为v1,v2, 然后在哈希map中查找和为target-v1-v2的所有二元对（在对应的链表中），查找的时间为O（1），为了保证不重复计算，我们只保留两个数下标都大于V2的二元对（其实我们在前面3sum问题中所求得的三个数在排序后的数组中下标都是递增的），即时是这样也有可能重复：比如排好序后数组为-9 -4 -2 0 2 4 4，target = 0，当第一个和第二个元素分别是-4，-2时，我们要得到和为0-（-2）-（-4） = 6的二元对，这样的二元对有两个,都是(2,4)，且他们在数组中的下标都大于-4和-2，如果都加入结果，则(-4,-2,2,4)会出现两次，因此在加入二元对时，要判断是否和已经加入的二元对重复（由于过早二元对之前数组已经排过序，所以两个元素都相同的二元对可以保证在链表中是相邻的，链表不会出现(2,4)->(1,5)->(2,4)的情况，因此只要判断新加入的二元对和上一个加入的二元对是否重复即可），因为同一个链表中的二元对两个元素的和都是相同的，因此只要二元对的一个元素不同，则这个二元对就不同。我们可以认为哈希map中key对应的链表长度为常数，那么算法总的复杂度为O（n^2）

Attention:

1. 想要将有相同和的对，存到链表中，可以构造value为数组的map.

<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"> unordered_map<int, vector<pair<int,int> > > pairs;</span></span></span>

2. 初始化map, 存储两两的和。注意j从i+1开始，否则会把自身求和算进去。

<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">for(int i = 0; i < n; i++)
       for(int j = i+1 ; j < n; j++)
             pairs[num[i]+num[j]].push_back(make_pair(i,j));</span></span></span>

3. 去除重复的手段和3Sum类似。

4. 针对pair的问题，我们还需要找到符合下标递增要求，并且不能有重复的数字添加（判断第三位是否一致）。

<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;">bool isFstpush = true;
//将符合要求的不重复且下标递增的pair存进答案
 for(int k = 0; k < sum2.size(); k++)
{
    if(sum2[k].first <= j) continue;
    //第一次存储的重复数字，或者不是重复数字，判断第三位是否相等
    if(isFstpush || (ret.back())[2] != ivec[sum2[k].first]){...}</span></span></span>

5. 注意pair的操作和数组调用原数组数字的使用。

<span style="font-size:14px;"><span style="font-size:14px;"><span style="font-size:14px;"> vector<int> tmp{ivec[i], ivec[j], ivec[sum2[k].first], ivec[sum2[k].second]}; </span></span></span>

6.reserve函数：

给vector预分配存储区大小，即capacity的值，但是没有给这段内存进行初始化。reserve 的参数n是推荐预分配内存的大小，实际分配的可能等于或大于这个值，即n大于实际分配空间的值，就会reallocate内存（实际分配空间的值）capacity的值会大于或者等于n 。这样，当ector调用push_back函数使得size 超过原来的默认分配的capacity值时避免了内存重分配开销。

需要注意的是：reserve 函数分配出来的内存空间，只是表示vector可以利用这部分内存，但vector不能有效地访问这些内存空间(在创建对象之前，不能引用容器内的元素)，访问的时候就会出现越界现象，导致程序崩溃。

<span style="font-size:14px;"><span style="font-size:14px;"> pairs.reserve(n*n);</span></span>

AC Code:

<span style="font-size:14px;"><span style="font-size:14px;">class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        int n = num.size();
        vector<vector<int> > ret;
        if(n < 4) return ret;
        vector<int> ivec(num);
        sort(ivec.begin(), ivec.end());
        unordered_map<int, vector<pair<int,int> > > pairs;
        pairs.reserve(n*n);
        
        //将n个数字的两两组合求和存进map 相同和的对在map中按照链表存储，即存在vector中 j从i+1开始
        for(int i = 0; i < n; i++)
        {
            for(int j = i+1; j < n; j++)
            {
                pairs[ivec[i] + ivec[j]].push_back(make_pair(i,j));
            }
        }
        
        for(int i = 0; i < n - 3; i++)
        {
            if(i > 0 && ivec[i] == ivec[i-1]) continue;
            for(int j = i+1; j < n - 2; j++)
            {
                if(j > i+1 && ivec[j] == ivec[j-1]) continue;
                if(pairs.find(target - ivec[i] - ivec[j]) != pairs.end())
                {
                    vector<pair<int, int> > sum2 = pairs[target - ivec[i] - ivec[j]];
                    bool isFstpush = true;
                    //将符合要求的不重复且下标递增的pair存进答案
                    for(int k = 0; k < sum2.size(); k++)
                    {
                        if(sum2[k].first <= j) continue;
                        //第一次存储的重复数字，或者不是重复数字，判断第三位是否相等
                        if(isFstpush || (ret.back())[2] != ivec[sum2[k].first])
                        {
                           vector<int> tmp{ivec[i], ivec[j], ivec[sum2[k].first], ivec[sum2[k].second]}; 
                           ret.push_back(tmp);
                           isFstpush = false;
                        }
                    }
                }
            }
        }
        
        return ret;
    }
    
};</span></span>