LeetCode题解——4Sum

题目：

给定一个数组，找出其中和为0的所有4个数组合，每个组合内的4个数非递降。

解法：

①先排序，然后利用4个指针，前两个遍历，后两个在第二个指针之后的部分里夹逼，时间O(N³)。

②或者利用一个哈希表先保存每两个数的和，然后类似于查找两个数的和等于给定值的过程。

代码：

①

 class Solution {
 public:
     vector<vector<int> > fourSum(vector<int> &num, int target) {
         vector<vector<int> > result;
         if(num.size() < )
             return result;
         sort(num.begin(), num.end());　　//先排序

         for(int a = ; a < num.size() - ; ++a)　　//a指向第一个数
         {
             if(a >  && num[a] == num[a-])
                 continue;

             for(int b = a + ; b < num.size() - ; ++b)　　//b指向第二个数
             {
                 if(b > a +  && num[b] == num[b-])
                     continue;

                 for(int c = b + , d = num.size() - ; c < d; )　　//c指向第三个数
                 {
                     if(c > b +  && num[c] == num[c-])
                     {
                         ++c;
                         continue;
                     }
                     if(d < num.size() -  && num[d] == num[d+])
                     {
                         --d;
                         continue;
                     }

                     int sum = num[a] + num[b] + num[c] + num[d];
                     if(sum == target)
                     {
                         result.push_back({num[a], num[b], num[c], num[d]});
                         ++c;
                         --d;
                     }
                     else if(sum < target)
                         ++c;
                     else
                         --d;
                 }
             }
         }
         return result;
     }
 };

②

 class Solution {
 public:
     vector<vector<int> > fourSum(vector<int> &num, int target) {
         vector<vector<int> > result;
         if(num.size() < )
             return result;
         sort(num.begin(), num.end());　　//先排序
         unordered_map<int, vector<pair<int, int> > > um;　　//哈希表，保存值为某一个数的所有数对

         for(int a = ; a < num.size() - ; ++a)
             for(int b = a + ; b < num.size(); ++b)
                 um[ num[a]+num[b] ].push_back(make_pair(a, b));

         for(int a = ; a < num.size() - ; ++a)
             for(int b = a + ; b < num.size() - ; ++b)
             {
                 vector<pair<int, int> > pv = um[target-num[a]-num[b]];

                 for(int i = ; i < pv.size(); ++i)
                     if(b < pv[i].first)　　　　//为了保证4个数有序
                         result.push_back({num[a], num[b], num[pv[i].first], num[pv[i].second]});
             }

         sort(result.begin(), result.end());　　　　//为了去除结果中的重复元素，先排序
         result.erase(unique(result.begin(), result.end()), result.end());　　//unique+erase去冗余
         return result;
     }
 };