LeetCode题解——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)

//类似于3Sum，固定2个数，另两个数为lo，hi遍历，使用技巧剪枝 pruning，可使得运算速度大大加快，O(n^3)，实际远小于O(n^3)

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> ans;
        if(nums.size()<4)  return ans;
     
        sort(nums.begin(),nums.end());
        
        int lo,hi;
        int MaxSize = nums.size();//可能组成4Sum的最大数字；
        for(int i=0; i<MaxSize-3; i++)
        {
            if(nums[i]+nums[MaxSize-1]+nums[MaxSize-2]+nums[MaxSize-3]<target) continue;//pruning is so magic
            if(nums[i]+nums[i+1]+nums[i+2]+nums[i+3]>target) break;//pruning is so magic
            if(nums[i]+nums[i+1]+nums[i+2]+nums[MaxSize-1]>target) MaxSize--;//更新MaxSize,注意边界情况的剪枝
            for(int j=i+1; j<MaxSize-2;j++)
            {
                if(nums[i]+nums[j]+nums[MaxSize-1]+nums[MaxSize-2]<target) continue;
                if(nums[i]+nums[j]+nums[j+1]+nums[j+2]>target) break;
                
                lo = j+1;
                hi = MaxSize-1;
                int want = target-nums[i]-nums[j];
                while(lo<hi)
                {
                    if(nums[lo]+nums[hi]==want)
                        {
                            vector<int> tm;
                            tm.push_back(nums[i]);
                            tm.push_back(nums[j]);
                            tm.push_back(nums[lo]);
                            tm.push_back(nums[hi]);
                            ans.push_back(tm);
                            while(lo<hi&&nums[lo]==nums[lo+1]) lo++;
                            while(lo<hi&&nums[hi]==nums[hi-1]) hi--;
                            lo++;
                            hi--;
                        }
                    else if(nums[lo]+nums[hi]>want) hi--;
                    else lo++;
                }
                while(nums[j]==nums[j+1]) j++;
            }
            while(nums[i]==nums[i+1]) i++;
        }
        return ans;
    }
};

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

        vector<int> solution(4,0);
        std::sort(nums.begin(),nums.end());
        int sum,a,b,c,d,Max_d_when_a_increase = nums.size() - 1,Max_d_when_b_increase;

        //a,b,c,d are the four index
        //Max_d_when_a_increase is the max possible d when a increase. To have the same sum, when a increase, d can only decrease
        //Max_d_when_b_increase is the max possible d when b increase

        for( a = 0; a < Max_d_when_a_increase - 2;a++ )
        {
            //remove dupilcate & pruning if a too small or too big
            if((a>0 && nums[a] == nums[a-1])
            || nums[a] + nums[Max_d_when_a_increase] + nums[Max_d_when_a_increase-1] + nums[Max_d_when_a_increase-2] < target) continue;
            if(nums[a]+nums[a+1]+nums[a+2]+nums[a+3] > target) break;            

            //update Max_d_when_a_increase
            sum = nums[a]+nums[a+1]+nums[a+2];
            while(sum+nums[Max_d_when_a_increase] > target)Max_d_when_a_increase--;
            Max_d_when_b_increase = Max_d_when_a_increase;

            solution[0] = nums[a];
            for( b=a+1; b < Max_d_when_b_increase - 1;b++)
            {
                //remove dupilcate & pruning if b too small or too big
                if((b>a+1 && nums[b] == nums[b-1])
                || nums[a] + nums[b] + nums[Max_d_when_b_increase-1] + nums[Max_d_when_b_increase] < target) continue;
                sum = nums[a] + nums[b]+nums[b+1];
                if(sum + nums[b+2] > target) break;

                //update Max_d_when_b_increase
                while(sum+nums[Max_d_when_b_increase]>target) Max_d_when_b_increase--;

                solution[1] = nums[b];
                c = b+1;
                d = Max_d_when_b_increase;
                sum = nums[a] + nums[b];
                while(c < d)//this are the same as two sum
                    if(sum + nums[c] + nums[d] == target)
                    {
                        solution[2]=nums[c];
                        solution[3]=nums[d];
                        result.push_back(solution);

                        do{c++;}while(c < d && nums[c] == nums[c-1]);
                        do{d--;}while(c < d && nums[d] == nums[d+1]);
                    }
                    else if(sum + nums[c] + nums[d] < target) 
                        do{c++;}while(c < d && nums[c] == nums[c-1]);
                    else do{d--;}while(c < d && nums[d] == nums[d+1]);
            }
        }
        return result;
    }
};*/