算法刷题day2

40. 组合总和 II

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的每个数字在每个组合中只能使用 一次 。

注意：解集不能包含重复的组合。 

例子：

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:[[1,1,6],
[1,2,5],
[1,7],
[2,6]]

思路 ：

把递归的每一层看做是固定vec

1.采用回溯算法，对candidates中的每一个数进行求和尝试；构造回溯函数。

变量：candidates是题目所给数组，vec用来记录当前的求和数列，target为题目所给目标值，index为当前所访问的变量在candidates中的下标，sum为当前vec中数的和。

void huisu(vector<int>&candidates,vector<int>&vec,int target,int index,int sum)

2.在每一层递归中，从下标index处访问candidates中剩余数。

 for(int i=index;i<candidates.size();i++)

3.每一次尝试求和会遇到如下三种情况：

1):sum+candidates[i]==target

此时我们将该数加入vec中，并将该vec存入最终的v中；这仅表示在当前层中，第i个数加上一层的vec等于target，我们存储完该结果后依然要在该层中继续寻找是否存在其他的情况，故使vec=s并continue；

if(sum+candidates[i]==target){//若和等于target，记录答案并返回
   vec.push_back(candidates[i]);
   sort(vec.begin(),vec.end());//使每组组内有序
   v.push_back(vec);//记录成立的组
   vec=s;//恢复当前层的vec
   continue;
}

2):sum+candidates[i]>target

当前这个数candidates[i]不能被固定为vec中的一个数，故continue继续寻找该层可能的数

else if(sum+candidates[i]>target){//带上当前数字会大于tar
       continue;
}

3):sum+candidates[i]<target

当前这个数可以被固定为vec中的一个数(不过我们并不知道包括或者不包括该数的vec最后能否求和等于target)。固定该数，然后递归寻找下一位数...递归返回，取消对该数的固定，继续寻找该层其他可能的数。

else{//小于tar
     vec.push_back(candidates[i]);//先将该数加入vec
     sum+=candidates[i];//当前的和
     huisu(candidates,vec,target,i+1,sum);//寻找下一个数
     sum-=candidates[i];//解除对该数的固定
     vec=s;
     continue;
}

4.返回答案

vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<int>vec;
        if(candidates.size()==0){//数组为空，直接返回
            return v;
        }
        huisu(candidates,vec,target,0,0);
        set<vector<int>>s(v.begin(),v.end());
        v.assign(s.begin(),s.end());//对结果去重
        return v;
    }

以上思路乍看没有什么问题，但在leetcode提交时遇到了超时的问题。这个输入样例中是大量重复的数字，我上述的想法以及代码会做大量无用的循环，消耗了大量的时间。

在思索过后，决定先对原candidates数组进行排序；

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

为了防止在同一层的for循环中多次选择相同的元素；如上图中，第一层会不断选取不同位置的1，第二层也会选取不同位置的1......因此要使得每一层不会多次选取相同的元素。所以可以在for循环的开始处加个判断：

if(i>index && candidates[i]==candidates[i-1]){
  continue;//如果当前数字下标大于该层循环传入的index，且该元素等于前一个元素，则直接跳过
  }

这样就进行了剪枝，时间复杂度就符合要求了。

以下是完整可执行代码：

#include<iostream>
#include<vector>
#include<algorithm>
#include<set>
#include <numeric>
using namespace std;
class Solution {
public:
    vector<vector<int>>v;
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<int>vec;
        if(candidates.size()==0){//如果candidates为空
            return v;
        }
        if(accumulate(candidates.begin(),candidates.end(),0)<target){//如果所有元素相加小于target
            return v;
        }
        sort(candidates.begin(),candidates.end());
        huisu(candidates,vec,target,0,0);
        return v;
    }
    void huisu(vector<int>&candidates,vector<int>&vec,int target,int index,int sum){
        vector<int>s=vec;
        if(index==candidates.size()){
                return;
        }
        for(int i=index;i<candidates.size();i++){
            if(i>index && candidates[i]==candidates[i-1]){
                continue;
            }
            if(sum+candidates[i]==target){//若和等于tar，记录答案并返回
                vec.push_back(candidates[i]);
                sort(vec.begin(),vec.end());//使每组组内有序
                v.push_back(vec);//记录成立的组
                vec=s;
                set<vector<int>>s(v.begin(),v.end());
                v.assign(s.begin(),s.end());
                continue;
            }
            else if(sum+candidates[i]>target){//带上当前数字会大于tar
                continue;
            }
            else{//小于tar
                vec.push_back(candidates[i]);//先带上
                sum+=candidates[i];
                huisu(candidates,vec,target,i+1,sum);
                sum-=candidates[i];
                vec=s;
                continue;
            }
        }
        return;
    }
};