LeetCode （18）4Sum

（18）4Sum

题目：在所给的数组中，寻找符合四个数和等于目标数的组合，返回所有组合。

例子：

所给数组为 S=[1, 0, -1, 0, -2, 2]，同时目标数为target = 0。
返回的集合为：
[
    [-1, 0, 0, 1],
    [-2, -1, 1, 2],
    [-2, 0, 0, 2]
]

这道题是属于3Sum的变形，这种情况下，同样适用3Sum的方法就可以了，我看很多人说KSum的问题，通过排序可以将复杂度控制在O(n^k-1)，所以在3Sum的O(n^2)的情况下多一层循环就是4Sum的O(n^3)的复杂度了，下面是代码：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int targetnum) {
        int len = nums.size();
        vector<vector<int>> s;
        if(len == 0){
            return s;
        }
        sort(nums.begin(), nums.end());
        int target = targetnum;
        int i, j, k, x;
        vector<int> temp;
        for(x = 0; x < len; x ++){
            if(x!=0){
                if(nums[x] == nums[x-1]){
                    continue;
                }
            }
        for(i=x+1;i<len;i++){
            if(i != x+1){
                if(nums[i] == nums[i-1]){
                    continue;
                }
            }
            target = targetnum;
            target = target - nums[i] - nums[x];
            j = i + 1;
            k = len - 1;
            while(j<k){
                if(nums[j] + nums[k] == target){
                    temp.push_back(nums[x]);
                    temp.push_back(nums[i]);
                    temp.push_back(nums[j]);
                    temp.push_back(nums[k]);
                    s.push_back(temp);
                    temp.clear();
                    while(j<k&&nums[j]==nums[j+1]){
                        j ++;
                    }
                    while(j<k&&nums[k]==nums[k-1]){
                        k --;
                    }
                    j++;
                    k--;
                }
                else if(nums[j] + nums[k] < target){
                    j ++;
                }
                else{
                    k --;
                }
            }
        }
        }
        return s;
    }
};