Combination Sum II&III

题目

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 (a₁, a₂, � , a_k) must be in non-descending order. (ie, a₁ ? a₂ ? � ? a_k).
• 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] 

思路一

类似 Permutations  和 Combination Sum

注意：加了判断重复的语句    if(i>start && num[i]==num[i-1])    continue;

class Solution {  
public:  
    vector<vector<int> > combinationSum2(vector<int> &num, int target) {  
        // Start typing your C/C++ solution below  
        // DO NOT write int main() function           
        vector<vector<int> > result;   
        sort(num.begin(),num.end());  
        vector<int> myvec;    
        combinationSum(result,num,0,myvec,target);        
        return result;    
    }    
        
    void combinationSum(vector<vector<int> > &result, vector<int> &num, int start, vector<int> &vec ,int target) {    
        // Start typing your C/C++ solution below     
        // DO NOT write int main() function    
        if(target==0)    
        {
            result.push_back(vec); 
            return ;
        }
        if(start>=num.size() || target<0)    
            return ;       
        for(int i=start;i<num.size();i++)    
        {    
            if(i>start && num[i]==num[i-1])  
                continue;              
            vec.push_back(num[i]);               
            combinationSum(result,num,i+1,vec,target-num[i]);    
            vec.pop_back();  
        }            
    }       
};    

思路二

用类似于  combinations   的方式：

class Solution {  
public:  
    vector<vector<int> > combinationSum2(vector<int> &num, int target) {  
        // Start typing your C/C++ solution below  
        // DO NOT write int main() function           
        vector<vector<int> > result;   
        sort(num.begin(),num.end());  
        vector<int> myvec;    
        combinationSum(result,num,0,myvec,target);        
        return result;    
    }    
        
    void combinationSum(vector<vector<int> > &result, vector<int> &num, int start, vector<int> &vec ,int target) {    
        // Start typing your C/C++ solution below     
        // DO NOT write int main() function    
        if(target==0)    
        {
            result.push_back(vec); 
            return ;
        }
        if(start>=num.size() || target<0)    
            return ;
        combinationSum(result,num,start+1,vec,target);
        vec.push_back(num[start]); 
        combinationSum(result,num,start+1,vec,target-num[start]);
        vec.pop_back();            
    }       
};    

但是会出现重复的集合 例如  [1,1] ,1  结果是 {1} , {1} 。

为了避免出现这种情况，我们用 set 的形式存储结果，来替代vector<vector<int>>

class Solution {  
public:  
    vector<vector<int> > combinationSum2(vector<int> &num, int target) {  
        // Start typing your C/C++ solution below  
        // DO NOT write int main() function           
        set<vector<int> > result;   
        sort(num.begin(),num.end());  
        vector<int> myvec;    
        combinationSum(result,num,0,myvec,target);        
        return vector<vector<int>>(result.begin(),result.end());    
    }    
        
    void combinationSum(set<vector<int> > &result, vector<int> &num, int start, vector<int> &vec ,int target) {    
        // Start typing your C/C++ solution below     
        // DO NOT write int main() function    
        if(target==0)    
        {
            result.insert(vec); 
            return ;
        }
        if(start>=num.size() || target<0)    
            return ;
        combinationSum(result,num,start+1,vec,target);
        vec.push_back(num[start]); 
        combinationSum(result,num,start+1,vec,target-num[start]);
        vec.pop_back();            
    }       
};    

可以顺利的通过小数据集合大数据集，但是相比思路一，时间要久一点。

最新 java

public class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
       List<List<Integer>> result = new ArrayList<List<Integer>>();
        List<Integer> list = new ArrayList<>();
        if(candidates == null || candidates.length == 0){
            return result;
        }
        // first sort the candidates;
        
        Arrays.sort(candidates);
        dfs(result, list, 0, candidates, target);
        
        return result;
    }
    
    private void dfs(List<List<Integer>> result, List<Integer> list, int cur, int[] candidates, int target){
        if(target == 0){
            result.add(new ArrayList(list));
        } 
        if(target < 0){
            return;
        }
        //depth search first with NST: add all nums
        for(int i=cur; i<candidates.length; i++){
            if(i>cur && candidates[i]==candidates[i-1]){
                continue;
            }
            list.add(candidates[i]);
            //one num can be used more than one times, so we don't add cur with 1
            dfs(result, list, i+1, candidates, target-candidates[i]);
            list.remove(list.size()-1);
        }
    }
}

III

Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.

Ensure that numbers within the set are sorted in ascending order.

Example 1:

Input: k = 3, n = 7

Output:

[[1,2,4]]

Example 2:

Input: k = 3, n = 9

Output:

[[1,2,6], [1,3,5], [2,3,4]]

public class Solution {
    public List<List<Integer>> combinationSum3(int k, int n) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        List<Integer> list = new ArrayList<>();
        dfs(result, list, 1, k, n);
        return result;
    }
    
    private void dfs(List<List<Integer>> result, List<Integer> list, int cur, int num, int target){
        if(num == 0 && target == 0){
            result.add(new ArrayList(list));
            return;
        } 
        if(num < 0 || target < 0){
            return;
        }
        //depth search first with NST: add all nums
        for(int i=cur; i<=9; i++){
            list.add(i);
            //one num can be used more than one times, so we don't add cur with 1
            dfs(result, list, i+1, num-1, target-i);
            list.remove(list.size()-1);
        }
    }
}