4Sum

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)

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<vector<int> > result;
        set<vector<int> > record;
        int size = num.size();
        if (size < 4) {
            return result;
        }
        vector<vector<int> > gots;
        sort(num.begin(), num.end());
        for (int i = 0; i < size - 3; ++i) {
            int new_target = target - num[i];
            if (get_sum3(num, i+1, new_target, gots)) {
                for (int j = 0; j < gots.size(); ++j) {
                    gots[j].insert(gots[j].begin(), num[i]);
                    if (record.find(gots[j]) == record.end()) {
                        record.insert(gots[j]);
                        result.push_back(gots[j]);
                    }
                }
                gots.clear();
            }
        }
        return result;
    }
    
    bool get_sum3(vector<int>& num, int begin, int target, vector<vector<int> >& results) {
        set<vector<int> > record;
        int sum = 0;
        int high;
        int low;
        vector<int> got;
        for (int i = begin; i < num.size() - 2; ++i) {
            high = num.size() - 1;
            low = i + 1;
            while (low < high) {
                sum = num[i] + num[low] + num[high] - target;
                if (sum < 0) {
                    ++low;
                } else if (sum > 0) {
                    --high;
                } else {
                    got.push_back(num[i]);
                    got.push_back(num[low]);
                    got.push_back(num[high]);
                    if (record.find(got) == record.end()) {
                        record.insert(got);
                        results.push_back(got);           
                    }
                    got.clear();
                    --high;
                }
            }
        }
        return !results.empty();
    }
};