[LeetCode]018-4-Sum

题目：
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)

Solution:
转化为3Sum->2Sum。

 vector<vector<int>> fourSum(vector<int>& nums, int target)
    {
        int n = nums.size();
        QuickSort(nums,0,n-1);

        int i,j,k,s,sum,t1,t2;
        vector<int> turple;
        vector<vector<int>> result;
        if(n < 4)
            return result;
        t1 = nums[0];
        for(i=0;i<n-3;i++)
        {
            if(i && t1 == nums[i])
                continue;
            t2 = nums[i+1];
            for(j=i+1;j<n-2;j++)
            {
                if(t2 == nums[j] && j >i+1)
                    continue;
                sum = target - nums[i] - nums[j];
                k = j+1;
                s = n-1;
                while(k<s)
                {
                    if(nums[k] + nums[s] == sum)
                    {
                        turple.push_back(nums[i]);
                        turple.push_back(nums[j]);
                        turple.push_back(nums[k]);
                        turple.push_back(nums[s]);
                        result.push_back(turple);
                        turple.clear();
                        k++;
                        s--;
                    }
                    else if(nums[k] + nums[s] < sum)
                        k++;
                    else
                        s--;
                 }
                t2 = nums[j];
             }
            t1 = nums[i];
        }
        result.erase(unique(result.begin(),result.end()),result.end());
        return result;
    }
    void QuickSort(vector<int>&nums,int low,int high)
    {
        if(low<high)
        {
            int pivot = nums[low];
            int first = low;
            int last = high;
            while(first<last)
            {
                while(nums[last] > pivot && last > first)
                {
                     --last;
                }
                nums[first] = nums[last];
                while(nums[first] <= pivot && last >first)
                {
                    ++first;
                }
                nums[last] = nums[first];
            }
            nums[first] = pivot;
            QuickSort(nums,low,first-1);
            QuickSort(nums,first+1,high);
        }
        else
            return;
    }

---

顺便提一个k-sum方法。思路基本是一样的。

    //nums是已经排好序的数组,beigin是这个数组起始位置，count是需要求和的数字的数目，target是求和的目标
    vector<vector<int>> K_Sum(vector<int>&nums,int begin,int count,int target)
    {
        vector<vector<int>>ret;
        vector<int> turple;
        set<int> n_set;
        if(count == 2)
        {
            //只求两个数的
            int i =begin;
            int j = nums.size()-1;
            while(i<j)
            {
                if(nums[i] + nums[j] ==  target && n_set.find(nums[i]) == n_set.end())
                {
                    turple.push_back(nums[i]);
                    turple.push_back(nums[j]);
                    n_set.insert(nums[i]);
                    n_set.insert(nums[j]);
                    ret.push_back(turple);
                    turple.clear();
                    i++;
                    j--;
                }
                else if(nums[i] + nums[j] <  target)
                    i++;
                else
                    j--;
            }
        }
        else
        {
            for(int i = begin;i<nums.size();i++)
            {
                if(n_set.find(nums[i]) == n_set.end())
                {
                    n_set.insert(nums[i]);
                    vector<vector<int>>subret =  K_Sum(nums,i+1,count-1,target - nums[i]);
                    if(!subret.empty())
                    {
                        for(int j=0;j<subret.size();j++)
                        {
                            subret[j].insert(subret[j].begin(),nums[i]);
                        }
                        ret.insert(ret.end(),subret.begin(),subret.end());
                    }
                }
            }
        }
        return ret;
    }