回溯法总结

回溯的核心在横向展开以及纵向递归，使用回溯相当于暴力求解，虽然可以利用剪枝进行一些优化，但是效率还是不会很高。

一般来说回溯问题可看作一棵树，树的每个节点时一个集合，树的横向展开即对集合中值不同的取法，纵向的递归就是一连串的取值导致的结果，最后这一连串的取值构成我们想要的结果，中途可以剪枝提高效率。递归后要修改某些变量的值达到回溯的效果。

例如：

这题每个节点的集合就是一个整数数组，然后取值是去取集合各个位置不同的值以横向展开，然后纵向展开即取完一个值后集合剩余的元素继续回溯。最后路径上的值的和若等于目标值则可以存入结果中。若和已经大于目标值则不需在回溯了。剪枝，代码如下：

class Solution {
private:
    vector path;
    vector> result;
    void backtracking(vector& candidates, int target, int position, int sum) {
        if (sum == target) {
            result.push_back(path);
            return;
        }
        if (sum > target)
            return;
        for (int i = position; i < candidates.size(); i++) {
            path.push_back(candidates[i]);
            sum += candidates[i];
            backtracking(candidates, target, i, sum);
            path.pop_back();
            sum -= candidates[i];
        }
    }
public:
    vector> combinationSum(vector& candidates, int target) {
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

这题树的每个节点的结合是一个字符串，然后对字符串取不同的子串横向展开，剩下的串纵向递归，若最后所有子串都是回文串（每次都要判断是否为回文串），则存入结果中。代码如下：

class Solution {
private:
    vector path;
    vector> result;
    bool isReverse(string s) {
        bool flag = true;
        for (int i = 0; i < s.size() / 2; i++) {
            if (s[i] != s[s.size() - i - 1])
                flag = false;
        }
        return flag;
    }
    void backtracking(string s) {
        if (s == "") {
            result.push_back(path);
            return;
        }
        string temp;
        for (int i = 0; i < s.size(); i++) {
            temp += s[i];
            if (isReverse(temp)) {
                path.push_back(temp);
                backtracking(string(s, i + 1, s.size() - i -1));
                path.pop_back();
            }
        }
    }
public:
    vector> partition(string s) {
        backtracking(s);
        return result;
    }
};