4Sum

Posted 2023-01-20 IIcyZhao

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();
    
;