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.

 solution: use recursion method.

    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>> ThreeSum(int start, vector<int>& nums, int target){
        vector<vector<int>> result;  
        for(int a = start; a <= nums.size() - 3;)  
        {  
            int b = a + 1;  
            int c = nums.size() - 1;  
            while(b < c)  
            {  
                int sum = nums[a] + nums[b] + nums[c];  
                if(sum == target){  
                    result.push_back({nums[start-1], nums[a], nums[b], nums[c]});  
                    c--;  
                    while(b < c && nums[c] == nums[c+1]) c--;  
                    b++;  
                    while(b < c && nums[b] == nums[b-1]) b++;  
                }  
                else if(sum > target){  
                    c--;  
                    while(b < c && nums[c] == nums[c+1]) c--;  
                }else{  
                    b++;  
                    while(b < c && nums[b] == nums[b-1]) b++;  
                }  
            }  
            a++;  
            while(a <= nums.size() - 3 && nums[a] == nums[a-1]) a++;  
        }  
        return result;  
    }
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
       if(nums.size() < 4){
           return {};
       }
       sort(nums.begin(), nums.end());
       vector<vector<int>> result;
       for(int i = 0 ; i < nums.size() - 3;)
       {
           vector<vector<int>> vectors = ThreeSum(i+1, nums, target - nums[i]);
           if(vectors.size() > 0)
                result.insert(result.end(), vectors.begin(), vectors.end());
            i++;
            while(i < nums.size() - 3 && nums[i] == nums[i - 1]) i++;
       }
       return result;
    }
};