Combination Sum

题目

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

思路

 注意：加了条件判断 vec[vec.size()-1]<=candidates[i] 可以防止 {1,4} 和{4,1}同时出现。

 

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

 

最新 java

public class Solution {
    
    // public List<List<Integer>> combinationSum(int[] candidates, int target) {
        
    //     List<List<Integer>> result = new ArrayList<List<Integer>>();
    //     if(candidates == null || candidates.length == 0) return result;
    //     List<Integer> current = new ArrayList<Integer>();
    //     Arrays.sort(candidates);
    //     combinationSum(candidates, target, 0, current, result);
    //     return result;
    // }
     
    // public void combinationSum(int[] candidates, int target, int j, List<Integer> curr, List<List<Integer>> result){
    //   if(target == 0){
    //       List<Integer> temp = new ArrayList<Integer>(curr);
    //       result.add(temp);
    //       return;
    //   }
     
    //   for(int i=j; i<candidates.length; i++){
    //       if(target < candidates[i]) 
    //             return;
    //       curr.add(candidates[i]);
    //       combinationSum(candidates, target - candidates[i], i, curr, result);
    //       curr.remove(curr.size()-1); 
    //   }
    // }
    
    public List<List<Integer>> combinationSum(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));
            return;
        } 
        if(target < 0){
            return;
        }
        //depth search first with NST: add all nums
        for(int i=cur; i<candidates.length; i++){
            list.add(candidates[i]);
            //one num can be used more than one times, so we don't add i with 1
            dfs(result, list, i, candidates, target-candidates[i]);  // always time limit is because i, not cur
            list.remove(list.size()-1);
        }
    }
}