98-Combination Sum II

-40. Combination Sum II My Submissions QuestionEditorial Solution
Total Accepted: 69805 Total Submissions: 250937 Difficulty: Medium
Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

Each number in C may only be used once in the combination.

Note:
All numbers (including target) will be positive integers.
Elements in a combination (a1, a2, … , ak) must be in non-descending order. (ie, a1 ≤ a2 ≤ … ≤ ak).
The solution set must not contain duplicate combinations.
For example, given candidate set 10,1,2,7,6,1,5 and target 8,
A solution set is:
[1, 7]
[1, 2, 5]
[2, 6]
[1, 1, 6]

时间复杂度：O(n!)
空间复杂度：O(n)
题意：
和上题类似，要从从集合取元素是不放回的
思路：类似的，不过是子树是严格递增的，
还有后面需要去重。（后面继续优化不必去重）

class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        vector<vector<int>> res;
        vector<int> tmp;
        dfs(candidates,target,0,tmp,res);
        sort(res.begin(),res.end());
        res.erase(unique(res.begin(),res.end()),res.end());
        return res;
    }
    void dfs(vector<int> &vec,int gap,int start,vector<int> &tmp,vector<vector<int>> &res)
    {
           if(gap==0){ //递归出口是找到满足条件的元素
               res.push_back(tmp);
               return;
           }
           else{
               int n=vec.size();
               for(int i=start;i<n;++i){
                   if(gap<vec[i])return;//剪枝
                   tmp.push_back(vec[i]);//放入中间结果集
                   dfs(vec,gap-vec[i],i+1,tmp,res); //进入子树，但是是标号严格递增式，i表示子问题在[当前元素下一元素,末尾元素]继续
                   tmp.pop_back(); //当前元素不合适，回退
               }
           }
    }
};

可以看到上述用了去重操作，这其实降低效率

所以更加高效的方法是：
在深搜的时候避免掉，当在深搜时，如果当前节点和上一个兄弟节点是一样的值，果断放弃（注意兄弟节点是递增排列的）

class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        vector<vector<int>> res;
        vector<int> tmp;
        dfs(candidates,target,0,tmp,res);
        return res;
    }
    void dfs(vector<int> &vec,int gap,int start,vector<int> &tmp,vector<vector<int>> &res)
    {
           if(gap==0){ //递归出口是找到满足条件的元素
               res.push_back(tmp);
               return;
           }
           else{
               int n=vec.size();
               int previous = -1;
               for(int i=start;i<n;++i){
                   if(gap<vec[i])return;//剪枝
                   if(vec[i]==previous)continue;
                   previous = vec[i];
                   tmp.push_back(vec[i]);//放入中间结果集
                   dfs(vec,gap-vec[i],i+1,tmp,res); //进入子树，但是是严格递增式，i表示子问题在[当前元素,末尾元素]继续
                   tmp.pop_back(); //当前元素不合适，回退
               }
           }
    }
};

这样结果beats 76.04%的元素