LeetCode题解——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 (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] 

Hide Tags

  Array Backtracking

Hide Similar Problems

  (M) Letter Combinations of a Phone Number (M) Combination Sum II (M) Combinations (M) Combination Sum III (M) Factor Combinations

首先将candidates排好序

第一种方法：递归，对于每个candidate[i]有三种情况：

（1）等于target，则candidate[i]是一种组合，加入res中，返回

（2）小于target，则判断candidate[i]与前面的数能否组成target,即递归调用 combinationSum(temp,target-candidates[i]*m);

（3）大于target， 则直接返回

class Solution {//递归36ms
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> ans;
        sort(candidates.begin(),candidates.end());
        if(candidates.size()==0) return ans;
        else if(candidates[0]>target) return ans;
        else if(candidates[0]==target) {
            vector<int> t; t.push_back(target);
            ans.push_back(t);
            return ans;
        }
    
        int N = candidates.size();
        
        for(int i=0; i<N; i++ )
        {
            if(candidates[i]==target)
            {
                vector<int> t;
                t.push_back(target);
                ans.push_back(t);
                break;
            }
            else if(candidates[i]<target)//看看前面能不能组合成target
            {
                 vector<int> temp;
                if(target%candidates[i]==0)
                {
                    for(int m=0; m<target/candidates[i]; m++)
                    {
                        temp.push_back(candidates[i]);
                    }
                    ans.push_back(temp);
                }
            
                temp.assign(candidates.begin(),candidates.begin()+i);
                for(int m=1; m<=target/candidates[i]; m++)
                {
                    vector<vector<int>> t;
                    t=combinationSum(temp,target-candidates[i]*m);
                    if(t.size()) 
                    {
                        for(int j=0;j<t.size();j++)
                        {
                            for(int l=0;l<m;l++)
                           { 
                                t[j].push_back(candidates[i]);
                           }
                           ans.push_back(t[j]);
                        }
                    }
                }
            
            }
        }
        return ans;
    }
};

第二种方法，DP

combinations[i] 表示组成i的组合，我们最终需要求得conbinations[target];

那么动态数组的大小为target+1，combinations[0]到combinations[target]，依次求出

class Solution {//DP54ms
public:
    vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
        sort(candidates.begin(), candidates.end());
        vector< vector< vector<int> > > combinations(target + 1, vector<vector<int>>());
        combinations[0].push_back(vector<int>());
        for (auto& score : candidates)
            for (int j = score; j <= target; j++){
                auto sls = combinations[j - score];
                if (sls.size() > 0) {
                    for (auto& s : sls)
                        s.push_back(score);
                    combinations[j].insert(combinations[j].end(), sls.begin(), sls.end());
                }
            }
        return combinations[target];
    }
};

第三种方法，递归，16ms,与第一种方法类似，但是省略了更多的错误组合的判断

class Solution {//递归16ms
public:
    vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
        sort(candidates.begin(), candidates.end());
        vector<vector<int> > res;
        vector<int> combination;
        combinationSum(candidates, target, res, combination, 0);//递归，找到和为target的所有组合
        return res;
    }
private:
    void combinationSum(vector<int> &candidates, int target, vector<vector<int> > &res, vector<int> &combination, int begin) {
        if  (!target) {
            res.push_back(combination);
            return;
        }
        for (int i = begin; i != candidates.size() && target >= candidates[i]; ++i) {//每循环一次结束，combination置0
            combination.push_back(candidates[i]);
            combinationSum(candidates, target - candidates[i], res, combination, i);
            combination.pop_back();
        }
    }
};