Combination Sum I&&II

Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

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 2,3,6,7 and target 7, 
A solution set is: 
[7] 
[2, 2, 3] 

 

需要注意的是题目给出的数据可能是乱序的，由于集合中每个元素可以用一次或多次，但是答案中不能有重复的组合，而且组合中的元素必须是非递减的顺序，因此刚开始需要对candidates进行排序，并且去重，然后对每个元素进行深搜。

深搜的每一步中都有两个选择，对第k个元素我们均可选也可不选

 

class Solution {
public:
    vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
        vector<int> path;   //存储解
        allpath.clear();
        sort(candidates.begin(), candidates.end()); //排序
        candidates.erase( unique(candidates.begin(), candidates.end()), candidates.end() ); //去重
        dfs(candidates, path, 0, target);
        return allpath;
    }
    
    void dfs(vector<int>& candidates, vector<int>& path, int k, int target) {
        if( target == 0 ) { //说明path中的元素相加等于target，这是有效解
            allpath.push_back(path);
            return ;
        }
        if( k>=candidates.size() || target < 0 ) return ;   //如果元素被搜完，或加上前个元素超出了target，那么是无效解
        path.push_back(candidates[k]);
        dfs(candidates, path, k, target-candidates[k]); //加入第k个元素是解之一
        path.pop_back();
        dfs(candidates, path, k+1, target); //不要第k个元素的情况
    }
    
private:
    vector< vector<int> > allpath;  //记录所有解
};

 

还有一种很通俗的算法，直接I&&II都秒杀，对每个子问题的数组中，重复的数字都不计算

class Solution {
public:
    vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
        vector<int> path;   //存储解
        allpath.clear();
        sort(candidates.begin(), candidates.end()); //排序
        dfs(candidates, path, 0, target);
        return allpath;
    }
    
    void dfs(vector<int>& candidates, vector<int>& path, int k, int target) {
        if( target == 0 ) { //说明path中的元素相加等于target，这是有效解
            allpath.push_back(path);
            return ;
        }
        for(int i=k; i<candidates.size() && target>=candidates[i]; ++i) {
            if( i>k && candidates[i] == candidates[i-1] ) continue; //当前子问题重复的数字不选择不计算
            path.push_back(candidates[i]);
            dfs(candidates, path, i, target-candidates[i]); //可选择同一个元素多次
            path.pop_back();
        }
    }
    
private:
    vector< vector<int> > allpath;  //记录所有解
};

 

 

Combination Sum II

 

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] 

 

用上面的方法二，只是下次搜索，不搜索当前的元素

class Solution {
public:
    vector<vector<int> > combinationSum2(vector<int> &num, int target) {
        vector<int> path;
        allpath.clear();
        sort(num.begin(), num.end());
        dfs(num, path, 0, target);
        return allpath;
    }
    
    void dfs(vector<int>& num, vector<int>& path, int k, int target) {
        if( target == 0 ) {
            allpath.push_back(path);
            return ;
        }
        for(int i=k; i<num.size() && target>=num[i]; ++i) {
            if( i>k && num[i] == num[i-1] ) continue;   //当前子问题中，重复的数字不选择
            path.push_back(num[i]);
            dfs(num, path, i+1, target-num[i]); //继续搜索下一个元素
            path.pop_back();
        }
    }
    
private:
    vector< vector<int> > allpath;
};