[array] leetcode - 39. Combination Sum - Medium

leetcode - 39. Combination Sum - Medium

descrition

Given a set of candidate numbers (C) (without duplicates) 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.
• 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]
]

解析

典型的回溯法求解。代码实现中给出了 3 中回溯的方式，都 accepted。微妙的区别应该是在递归的层数不同。对于 candidates[index] 只有两种情况，即：选择或不选择，值得注意的是如果选择的话可以多次重复选择。（可以使用状态转换图进行抽象更便于理解，重复选择实际上是在 index 状态有环，而不选择则是向 index + 1 状态的迁移）

注意：

• 调用函数前用了一个排序，主要是为了递归时剪枝做准备，数组是递增排序，如果太大则可以停止更深层的递归
• 题目说了所有数都是 positive，这其实也可以作为剪枝的条件
• 题目说数组中不存在 duplicate 元素，如果存在的话还需要跳过重复的元素。

一般的，对于回溯问题，找好递归求解的子结构，记得结束点即出口的检查，避免无限循环。在递归过程中可以思考是否可以进行剪枝。

code

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Solution{
public:
    vector<vector<int> > combinationSum(vector<int>& candidates, int target){
        vector<vector<int> > ans;
        vector<int> vecCur;
        sort(candidates.begin(), candidates.end());
        
        combinationSumBacktracking0(candidates, 0, target, vecCur, ans);
        //combinationSumBacktracking1(candidates, 0, target, vecCur, ans);
        //combinationSumBacktracking2(candidates, 0, target, vecCur, ans);
        return ans;
    }

    // candidates in ascending
    void combinationSumBacktracking0(vector<int>& candidates, int index, int target, 
                        vector<int>& vecCur, vector<vector<int> >& ans){
        if(target < 0)
            return;
        if(target == 0 && !vecCur.empty()){
            ans.push_back(vecCur);
            return;
        }
        // sub-problem, for each element in candidates[index,...,n-1]
        // just have two condition: choose or not
        for(int i=index; i<candidates.size(); i++){
            if(candidates[i] > target) // Note: candidates must in ascending order
                break;
            // note: not i+1, because the same repeaded number may be chosen from candidates
            vecCur.push_back(candidates[i]);
            combinationSumBacktracking0(candidates, i, target - candidates[i], vecCur, ans);
            vecCur.pop_back();
        }
    }

    void combinationSumBacktracking1(vector<int>& candidates, int index, int target,
                                    vector<int>& vecCur, vector<vector<int> >& ans){
        if(target < 0)
            return;
        if(target == 0){
            if(!vecCur.empty())
                ans.push_back(vecCur);
            return;
        }
        if(index >= candidates.size())
            return;

        // choose candidates[index]
        // Note: candidates[index] can be choose more than onece
        vecCur.push_back(candidates[index]);
        combinationSumBacktracking1(candidates, index, target - candidates[index], vecCur, ans);
        vecCur.pop_back();

        // dosen‘t choose candidates[index]
        combinationSumBacktracking1(candidates, index+1, target, vecCur, ans);
    }

    void combinationSumBacktracking2(vector<int>& candidates, int index, int target,
                                     vector<int>& vecCur, vector<vector<int> >& ans){
        if(target < 0)
            return;
        if(target == 0){
            if(!vecCur.empty())
                ans.push_back(vecCur);
            return;
        }
        if(index >= candidates.size())
            return;

        // choose candidates[index] more than times
        int i = 1;
        for(; i*candidates[index] <= target; i++){
            vecCur.push_back(candidates[index]);
            combinationSumBacktracking2(candidates, index+1, target - i*candidates[index], vecCur, ans);
        }
        for(int j=i-1; j>=1; j--)
            vecCur.pop_back();

        // don‘t choose candidates[index]
        combinationSumBacktracking2(candidates, index+1, target, vecCur, ans);
    }
};

int main()
{
    return 0;
}