回溯递归实现一个数组求目标值

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        vector<int> val;
        set<vector<int>> s;      //用于去重的，可以去掉
        gen(nums,target,val,res,0,4,s);      //4表示要输出的是个四个数之和，可以去掉或修改。
        return res;
    }
    void gen(vector<int>& nums,int target,vector<int>& val,vector<vector<int>>& res,int tmp,int k,set<vector<int>>& s)
   {
        if(target == 0 && k == 0)
        {
            vector<int> sor;
            sor = val;
            sort(sor.begin(),sor.end());
            if(s.find(sor) == s.end())
            {
                s.insert(sor);
                res.push_back(val);
            }
        }
        else
        {
            for(int i = tmp;i < nums.size();i++)
            {
                if (i > tmp && nums[i] == nums[i - 1])      //屏蔽相邻重复的数字
                    continue;
                val.push_back(nums[i]);
                gen(nums,target-nums[i],val,res,i+1,k-1,s);      //主要部分
                val.pop_back();
            }
        }

    }
};

//求四数之和
class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
       vector<vector<int> > res;
        int len=nums.size();
        if(len==0)
            return res;
        sort(nums.begin(),nums.end());
        return kSum(nums,0,4,target);
    }
     vector<vector<int> > kSum(vector<int>& nums, int start, int k, int target)      //n数之和 
    {
        vector<vector<int> > res;
        int len=nums.size();
        if(k==2)
        {
            int left=start,right=len-1;
            int lastleftval=-1,lastrightval=-1;
            bool flag=false;// flag=false表示还未满足条件的元祖
            while(left<right)
            {
                if((nums[left]+nums[right])>target)
                    right--;
                else if((nums[left]+nums[right])<target)
                    left++;
                else
                {
                    if(flag==true && lastleftval==nums[left] && lastrightval==nums[right])
                    {
                        left++;
                        right--;
                        continue;
                    }
                    flag=true;
                    lastleftval=nums[left];
                    lastrightval=nums[right];
                    vector<int> subres;
                    subres.push_back(nums[left]);
                    subres.push_back(nums[right]);
                    res.push_back(subres);
                    left++;
                    right--;
                }
            }
            return res;
        }
        int lastval=-1;
        for(int i=start; i<len; i++)
        {
            if(i!=start && nums[i]==nums[i-1])
                continue;
            vector<vector<int> > subres= kSum(nums, i+1, k-1, target-nums[i]);
            int sublen=subres.size();
            for(int j=0; j<sublen; j++)
            {
                vector<int>temp;
                temp.push_back(nums[i]);
                for(int j1=0; j1<k-1; j1++)
                    temp.push_back(subres[j][j1]);
                res.push_back(temp);
            }
        }
        return res;
    }
};