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:
    static bool compare_func(const int d1, const int d2) {  
        return d1 < d2;  
    }

    vector > fourSum(vector &num, int target) {
         int i, j, k, l;  
         vector< vector > data;  
         vector element(4);  
         sort(num.begin(), num.end(), compare_func);  
         if(num.size() < 4) return data;
         for(i = 0; i < num.size() - 1; i++) { 
             if(i != 0 && num[i] == num[i - 1]) continue;  
             for(l = i + 1; l < num.size(); ) {
                 for(j = l + 1, k = num.size() - 1; j < k ; ) {  
                     if(num[j] + num[k] + num[i] + num[l] < target) {  
                         j++;  
                     }  
                     else if(num[j] + num[k] + num[i] + num[l] > target) {  
                         k--;  
                     }  
                     else {  
                         element[0] = num[i];
                         element[1] = num[l];
                         element[2] = num[j];  
                         element[3] = num[k];  
                         data.push_back(element);  
                         while(num[++j] == num[j - 1] && j < k);       
                         while(num[--k] == num[k + 1] && j < k);    
                     }  
                 }
                 while(num[++l] == num[l - 1] && l < num.size());    
             }
         }  
         return data;  
    }
};