4Sum -- leetcode

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)

算法一，在3sum基础上，再套上一层循环。时间复杂度为O(n^3)

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<vector<int> > result;
        if (num.size() < 4) return result;

        sort(num.begin(), num.end());
        for (int i=0; i< num.size(); i++) {
                if (i && num[i] == num[i-1])
                        continue;

                for (int j=i+1; j<num.size(); j++) {
                        if (j>i+1 && num[j] == num[j-1])
                                continue;

                        int p = j+1, q = num.size()-1;
                        while (p < q) {
                                const int sum = num[i] + num[j] + num[p] + num[q];
                                if (sum == target) {
                                        vector<int> b;
                                        b.push_back(num[i]);
                                        b.push_back(num[j]);
                                        b.push_back(num[p]);
                                        b.push_back(num[q]);
                                        result.push_back(b);
                                        while (++p < q && num[p] == num[p-1]);
                                        while (--q > p && num[q] == num[q+1]);
                                }
                                else if (sum < target)
                                        ++p;
                                else
                                        --q;
                        }

                }
        }

        return result;
    }
};

算法2: 利用hash查找。时间复杂度O(n^2 log n)。

此算法时间复杂度要优于算法1。表面上看起来，它的运行速度也会快于算法1.

但实则不然，在leetcode上，统计显示，此算法时间已经沦为用java或者python的时间范围内。远不如算法1快。

这可能是因为它存在大量的内存分配请求和内存拷贝的原因，而导致它比算法1慢。

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        sort(num.begin(), num.end());
        set<vector<int> > result;
        unordered_map<int, set<pair<int, int> > > hash;
        for (int i=0; i<num.size(); i++) {
                for (int j=i+1; j<num.size(); j++) {
                        if (j>i+1 && num[j] == num[j-1])
                                continue;

                        const auto iter = hash.find(target-num[i]-num[j]);
                        if (iter != hash.end()) {
                                for (auto &p: iter->second) {
                                        vector<int> b = {p.first, p.second, num[i], num[j]};
                                        result.insert(b);
                                }
                        }
                }

                for (int j=0; j<i; j++) {
                        if (!j || num[j] != num[j-1])
                                hash[num[j]+num[i]].insert(make_pair(num[j], num[i]));
                }
        }
        return vector<vector<int> >(result.begin(), result.end());
    }
};