回溯法-leetcode

在包含问题的所有解的解空间树中，按照深度优先搜索的策略，从根结点出发深度探索解空间树。当探索到某一结点时，要先判断该结点是否包含问题的解，如果包含，就从该结点出发继续探索下去，如果该结点不包含问题的解，则逐层向其祖先结点回溯。（其实回溯法就是对隐式图的深度优先搜索算法）。

39. Combination Sum

回溯法应用。
注意元素可以重复，所以下一次递归总是从当前递归元素开始。

class Solution {
public:
    void dfs(vector<int>& candidates, int target, int begin, vector<int>& subRes, vector<vector<int>>& res) {
        if (!target) {
            res.push_back(subRes);
            return;
        }
        for (int i = begin; i < candidates.size() && target >= candidates[i] ; ++i) {
            subRes.push_back(candidates[i]);
            dfs(candidates, target - candidates[i], i, subRes, res);
            subRes.pop_back();
        } 
    }

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> res;
        vector <int> subRes;
        if (candidates.empty()) return res;
        sort(candidates.begin(), candidates.end());
        dfs(candidates, target, 0, subRes, res);
        return res;
}    
};

40. Combination Sum II

此题是Combination Sum的扩展，但是每个元素最多只能选用一次。由于有重复元素的存在，可能出现重复结果。所以除了从i+1开始之外，我们可以如下处理：在for循环中，提前当前数是否跟上一个数相等，如果相等，跳过。

class Solution {
public:
    void dfs(vector<int>& candidates, int target, int begin, vector<int>& subRes, vector<vector<int>>& res) {
        if (!target) {
            res.push_back(subRes);
            return;
        }
        for (int i = begin; i < candidates.size(); ++i) {
            if (i > begin && candidates[i] == candidates[i-1]) continue;
            if (target < candidates[i]) return;
            subRes.push_back(candidates[i]);
            dfs(candidates, target - candidates[i], i+1, subRes, res);
            subRes.pop_back();
        } 
    }

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<vector<int>> res;
        vector <int> subRes;
        if (candidates.empty()) return res;
        sort(candidates.begin(), candidates.end());
        dfs(candidates, target, 0, subRes, res);
        return res;
}    
};

216. Combination Sum III

这题是上一题的变种，重点就是加了个size的判断，同时是1到9.

class Solution {
public:
    void dfs(int size, int target, int begin, vector<int>& subRes, vector<vector<int>>& res) {
        if (target == 0 && subRes.size() == size) {
            res.push_back(subRes);
            return;
        }
        for (int i = begin; i < 10; ++i) {
            if (target < i) return;
            subRes.push_back(i);
            dfs(size, target - i, i+1, subRes, res);
            subRes.pop_back();
        } 
    }

    vector<vector<int>> combinationSum3(int k, int n) {
        vector<vector<int>> res;
        vector <int> subRes;
        if (k <= 0 || n <= 0) return res;
        dfs(k, n, 1, subRes, res);
        return res;
}    
};