18. 4Sum

18. 4Sum

一开始想用O(n^2)复杂度解决它，两对变量两边变动，但是我发现在中间那一对为0的情况下，最两端的不知道怎么走。虽然可以使用一个队列存起来，但是感觉太麻烦了。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        int nums_len = nums.size();
        vector<vector<int>> result;

        sort(nums.begin(), nums.end());

        int lowleft1 = 0, lowleft2 = 1, highright1 = nums_len - 2, highright2 = nums_len - 1; 
        while(lowleft1 < lowleft2 && lowleft2 < highright1 && highright1 < highright2) {

            int l2 = lowleft2, r1 = highright1;
            int sum_tmp = 0;
            int sum_1st = nums[lowleft1] + nums[l2] + nums[r1] + nums[highright2] - target;
            // cout << "first loop" << endl;
            while(l2 < r1) {
                // cout << "second loop" << endl;
                vector<int> tmp;
                cout << nums[lowleft1] << " " << nums[l2] << " " << nums[r1] << " " <<  nums[highright2] << endl;
                sum_tmp = nums[lowleft1] + nums[l2] + nums[r1] + nums[highright2];
                if(sum_tmp == target) {
                    tmp.push_back(nums[lowleft1]);
                    tmp.push_back(nums[l2]);
                    tmp.push_back(nums[r1]);
                    tmp.push_back(nums[highright2]);
                    result.push_back(tmp);
                }
                /*
                while(l2 < r1 && nums[l2] == nums[l2 + 1])
                    l2++;
                while(r1 > l2 && nums[r1] == nums[r1 - 1])
                    r1--; */
                sum_tmp -= target;
                if(sum_tmp < 0)
                    l2++;
                else
                    r1--;
            }
            /*
            while(highright2 > lowleft1 && nums[highright2] == nums[highright2 - 1] )
                highright2--;
            while(lowleft1 < highright2 && nums[lowleft1] == nums[lowleft1 + 1])
                lowleft1++;*/
            if(sum_1st > 0)
                highright2--;
            else
                lowleft1++;

            lowleft2 = lowleft1 + 1;
            highright1 = highright2 - 1;
        }

        return result;
    }
};

修改成O(n^3)的算法：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        int nums_len = nums.size();
        vector<vector<int>> result;
        set<vector<int>> rel_set;

        sort(nums.begin(), nums.end());

        int lowleft1 = 0, lowleft2 = 1, highright1 = nums_len - 2; 
        int t1 = INT_MAX, t2 = INT_MAX, t3 = INT_MAX, t4 = INT_MAX;

        while(lowleft1 < lowleft2 && lowleft2 < highright1) {

            for(int l2 = lowleft1 + 1; l2 < nums_len - 2; l2++) {
                int r1 = l2 + 1, r2 = nums_len - 1;

                while(r1 < r2){
                    int sum_tmp = nums[lowleft1] + nums[l2] + nums[r1] + nums[r2];
                    vector<int> tmp;

                    // cout << nums[lowleft1] << " " << nums[l2] << " " << nums[r1] << " " << nums[r2] << endl;

                    if(sum_tmp == target) {
                        if(t1 != nums[lowleft1] || t2 != nums[l2] || t3 != nums[r1] || t4 != nums[r2]) {
                            tmp.push_back(nums[lowleft1]);    
                            tmp.push_back(nums[l2]);
                            tmp.push_back(nums[r1]);
                            tmp.push_back(nums[r2]);
                           // result.push_back(tmp);
                            rel_set.insert(tmp);
                            t1 = nums[lowleft1];
                            t2 = nums[l2];
                            t3 = nums[r1];
                            t4 = nums[r2];
                        }
                    }

                    // while(r1 < r2 && nums[r1] == nums[r1+1])
                    //    r1++;
                    //while(r1 < r2 && nums[r2] == nums[r2-1])    
                    //    r2--;
                    sum_tmp -= target;

                    if(sum_tmp > 0)
                        r2--;
                    else
                        r1++;
                }

                while(l2 < highright1 && nums[l2] == nums[l2+1])
                    l2++;
            }
            /*
            int f = 0;
            while(lowleft1 < nums_len - 2 && nums[lowleft1] == nums[lowleft1+1]) {
                lowleft1++;
                f = 1;
            }    

            if(!f) */    
            lowleft1++;    
            lowleft2 = lowleft1 + 1;
        }

        for (std::set<vector<int>>::iterator it=rel_set.begin(); it!=rel_set.end(); ++it){
            vector<int> tmp = *it;
            result.push_back(tmp);
            // std::cout << tmp[0] << " " << tmp[1] << " " << tmp[2] << " " << tmp[3] << endl;
        }


        return result;
    }
};

效率更高的算法：（这个算法考虑很多不需要计算的边界）

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> total;
        int n = nums.size();
        if(n<4)  return total;
        sort(nums.begin(),nums.end());
        for(int i=0;i<n-3;i++)
        {
            if(i>0&&nums[i]==nums[i-1]) continue;
            if(nums[i]+nums[i+1]+nums[i+2]+nums[i+3]>target) break;
            if(nums[i]+nums[n-3]+nums[n-2]+nums[n-1]<target) continue;
            for(int j=i+1;j<n-2;j++)
            {
                if(j>i+1&&nums[j]==nums[j-1]) continue;
                if(nums[i]+nums[j]+nums[j+1]+nums[j+2]>target) break;
                if(nums[i]+nums[j]+nums[n-2]+nums[n-1]<target) continue;
                int left=j+1,right=n-1;
                while(left<right){
                    int sum=nums[left]+nums[right]+nums[i]+nums[j];
                    if(sum<target) left++;
                    else if(sum>target) right--;
                    else{
                        total.push_back(vector<int>{nums[i],nums[j],nums[left],nums[right]});
                        do{left++;}while(nums[left]==nums[left-1]&&left<right);
                        do{right--;}while(nums[right]==nums[right+1]&&left<right);
                    }
                }
            }
        }
        return total;
    }
};