1.回溯算法.基础

基础知识

回溯法也可以叫做回溯搜索法，它是一种搜索的方式。回溯是递归的副产品，只要有递归就会有回溯
因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质。

回溯算法能解决的问题：

• 组合问题：N个数里面按一定规则找出k个数的集合
• 切割问题：一个字符串按一定规则有几种切割方式
• 子集问题：一个N个数的集合里有多少符合条件的子集
• 排列问题：N个数按一定规则全排列，有几种排列方式
• 棋盘问题：N皇后，解数独等等

理解回溯法：
回溯法解决的问题都可以抽象为树形结构，所有回溯法的问题都可以抽象为树形结构。因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度就构成了树的深度。
递归就要有终止条件，所以必然是一棵高度有限的树（N叉树）。

回溯法模板

• 回溯函数模板返回值以及函数，习惯是函数起名字为backtracking，函数返回值一般为void
• 回溯函数终止条件，一般来说是搜到叶子节点了
• 回溯搜索的遍历过程
  
  for循环就是遍历集合的区间，一个节点有多少个子节点，for循环就会执行多少次。

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

这份模板很重要，后面做回溯法的题目都基本是按照该模板解决。
回溯和递归是相辅相成的，回溯法的效率，回溯法其实就是暴力查找，并不是什么高效的算法。最后我们讲到回溯法解决的问题都可以抽象为树形结构（N叉树），。并给出了回溯法的模板。

---

题目

1.组合

（题目链接）
给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
这题是回溯法的经典题目，直接解法是通过k个for循环，不考虑顺序的情况下完成组合问题。但当k值较大时，暴力搜索的代码太过冗长。因此可以使用递归法，每次递归中嵌套一个for循环，那么递归就可以用于解决过曾的嵌套系统问题。例如：

    std::vector<std::vector<int>> res;
    std::vector<int> path;
    void backtracking(int n, int k, int startindex){
        if(path.size()==k){
            res.push_back(path);
            return;
        }

        for(int i=startindex; i<=n; i++){
            path.push_back(i);
            backtracking(n, k, i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> combine(int n, int k) {
        res.clear();
        path.clear();
        backtracking(n,k,1);
        return res;
    }

---

2.组合-优化

题目1中的回溯法是可以剪枝优化的，可以剪枝的地方就在递归中每一层的for循环所选择的起始位置，以此避免一些没有必要的循环。在组合问题中如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。
1.已经选择的元素个数：path.size()；2.所需需要的元素个数为: k - path.size()；3.列表中剩余元素（n-i） >= 所需需要的元素个数（k - path.size()）；4.在集合n中至多要从该起始位置 : i <= n - (k - path.size()) + 1，这里+1是因为for循环取的索引值是左闭区间。
修改之后的for循环条件如下

for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) // i为本次搜索的起始位置

---

3.组合总和|||

（题目链接）
找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。说明：所有数字都是正整数；解集不能包含重复的组合。
这题相当于在组合问题的基础上多了一个限制，就是找到和为n的k个数的组合，而整个集合已经是固定的1~9。

    std::vector<std::vector<int>> res;
    std::vector<int> path;
    void backtracking(int tarSum, int k, int sum, int startindex){
        if(path.size()==k && sum == tarSum){
            res.push_back(path);
        }

        for(int i=startindex; i<=9 - (k - path.size()) + 1; i++){
            sum += i;
            path.push_back(i);
            if(sum > tarSum){
                sum -= i;
                path.pop_back();
                return;
            }
            backtracking(tarSum, k, sum, i+1);
            sum -= i;
            path.pop_back();
        }
    }    
    vector<vector<int>> combinationSum3(int k, int n) {
        res.clear();
        path.clear();
        backtracking(n, k, 0, 1);
        return res;
    }

---

4.电话号码和字母组合

（题目链接）
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合

例如：输入：“23”；输出：[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]。（尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。）
根据输入的数字，可以分为一层递归，所以本题是要解决如下三个问题：

• 数字和字母的映射
• 输入数字还包含异常的情况，例如1*#的情况

解决第一个问题，需要建立一个0~9队形string charMap[10]的字符串数组结构；
确定回溯函数参数：需要字符串收集叶子节点的结果，然后用一个字符串数组res保存，这两个变量设置为全局。除此之外，局部变量为接收题目中给的string digits，以及int index-记录digits第几个数字。
返回条件，当index==digits.size()。

    const string letterMap[10] = {
        "", // 0
        "", // 1
        "abc", // 2
        "def", // 3
        "ghi", // 4
        "jkl", // 5
        "mno", // 6
        "pqrs", // 7
        "tuv", // 8
        "wxyz", // 9
    };
    std::vector<std::string> res;
    std::string s;
    void backtracking(const string& digits, int index){
        if(index==digits.size()){
            res.push_back(s);
            return;
        }
        int digit = digits[index]-'0';
        string letters = letterMap[digit];
        for(int i=0; i<letters.size(); i++){
            s.push_back(letters[i]);
            backtracking(digits, index+1);
            s.pop_back();
        }
    }
    
    vector<string> letterCombinations(string digits) {
        res.clear();
        s.clear();
        if(digits.size()==0) return res;
        backtracking(digits, 0);
        return res;
    }

此时不需要在backtracking中设置startindex，因为是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex。但如果是一个集合来求组合的话，就需要startIndex。
时间复杂度: O(3^ m*4^ n , 空间复杂度: O(3^ m * 4^n)，其中 m 是对应三个字母的数字个数，n 是对应四个字母的数字个数。

---

5.组合总和

（题目链接）
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。说明：candidates 中的数字可以无限制重复被选取；所有数字（包括 target）都是正整数；解集不能包含重复的组合。例如输入：candidates = [2,3,5], target = 8；所求解集为： [ [2,2,2,2], [2,3,3], [3,5] ]。
与之前组合问题不同的是，这题没有数量的限制，可以无限重复，但总和有限制，所以递归的次数也是有限制的。
递归函数参数：两个全局变量，二维数组result存放结果集，数组path存放符合条件的结果；题目传入的集合candidates, 和目标值target。使用int sum来统计path里的总和，同时需要startindex来控制for循环的起始位置
终止条件：当sum大于等于tarsum时，递归终止。
当然这题也是可以作剪枝优化处理的，就是在for循环条件-如果下一层的sum（就是本层的 sum + candidates[i]）已经大于target，就可以结束本轮for循环的遍历

    std::vector<std::vector<int>> res;
    std::vector<int> path;
    void backtracking(std::vector<int>& candidates, int target, int sum, int startindex){
        if(sum==target){
            res.push_back(path);
            return;
        }

        for(int i=startindex; i<candidates.size() && sum+candidates[i]<=target; i++){
            sum += candidates[i];
            path.push_back(candidates[i]);
            // 此处传入i，而不是i+1，是因为元素可以重复
            backtracking(candidates, target, sum, i);
            sum -= candidates[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        res.clear();
        path.clear();
        std::sort(candidates.begin(), candidates.end());
        // 排序有利于加速剪枝
        backtracking(candidates, target, 0, 0);
        return res;
    }

---

6.组合总和II

（题目链接）
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。说明：candidates 中的每个数字在每个组合中只能使用一次，所有数字（包括目标数）都是正整数。解集不能包含重复的组合
这题与第4题的区别是，candidates中的数字只能用一次，而且该数组可能存在重复的元素。正确理解重复的组合：“使用过”在组合问题（树形结构）上有两个维度：同一个树枝上使用，同一个数层上使用。结合题目我们要去重的是同一树层上”使用过“的元素，同一树枝上都是一个组合里的元素，不用去重。

因此需要还需要加一个bool型数组used，用来记录同一树枝上的元素是否使用过。

    std::vector<std::vector<int>> res;
    std::vector<int> path;
    void backtracking(std::vector<int>& candidates, int target, int sum, int startindex, std::vector<bool> used){
        if(sum==target){
            res.push_back(path);
            return;
        }

        for(int i=startindex; i<candidates.size() && sum+candidates[i]<=target;i++ ){
        	// 这一步的基础是sort，因此相等的元素会排列在一起
            if(i>0 && candidates[i]== candidates[i-1] && used[i-1]==false) continue;
            sum += candidates[i];
            path.push_back(candidates[i]);
            used[i] = true;
            backtracking(candidates, target, sum, i+1, used);
            sum -= candidates[i];
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        std::vector<bool> used(candidates.size(), false);
        res.clear();
        path.clear();
        std::sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0, used);
        return res;
    }

7.分割回文串

（题目链接）
给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。返回 s 所有可能的分割方案。例如示例: 输入: “aab” 输出: [ [“aa”,“b”], [“a”,“a”,“b”] ]

切割问题其实类似组合问题：切割问题最后可以抽象为一颗树的结构

• 组合问题：选取一个a之后，在bcdef中再去选取第二个，选取b之后在cdef中再选取第三个…。
• 切割问题：切割一个a之后，在bcdef中再去切割第二段，切割b之后在cdef中再切割第三段…。
  
  递归函数参数：全局变量数组path存放切割后回文的子串，二维数组result存放结果集。参数还需要startIndex，因为切割过的地方，不能重复切割。递归参数需要传入startIndex，表示下一轮递归遍历的起始位置，这个startIndex就是切割线。另外切割的是以startindex的左闭区间，因此当startindex0时会出现空切==的情况出现。
  终止条件：切割线切到了字符串最后面，说明找到了一种切割方法。
  如何判断回文字符串：使用双指针法，左端，右端向中间靠拢，令char[i]==char[j]就是回文字符串。

    std::vector<std::vector<std::string>> res;
    std::vector<std::string> path;
    void backtracking(std::string& s, int startindex){
        if(startindex>=s.size()){
            res.push_back(path);
            return;
        }
        for(int i=startindex; i<s.size() ; i++){
            if(ispalindrome(s, startindex, i)){
                std::string str = s.substr(startindex, i-startindex+1);
                path.push_back(str);                
            }
            else continue;
            backtracking(s, i+1);
            path.pop_back();
        }
    }
    bool ispalindrome(const std::string& s, int start, int end){
        for(int i=start, j=end; i<j; i++, j--){
            if(s[i]!=s[j]) return false;
        }
        return true;
    }
    vector<vector<string>> partition(string s) {
        res.clear();
        path.clear();
        backtracking(s, 0);
        return res;
    }

---

8.复原IP地址

（题目链接）
给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。
递归参数：这题类似分割回文串，因为需要添加逗号，需要设置变量pointNum记录；
递归终止条件：当pointNum==3时，验证一下第四段是否合法，如果合法就加入集合里；
单层搜索的逻辑：在循环遍历里截取子串，不过需要判断该子串是否合法，如果合法，则添加.表示已经分割；如果不合法就结束本层循环。
判断子串是否合法：段位以0为开头的数字不合法；段位里有非整数字符；段位大于255

    std::vector<std::string> res;
    void backtracking(std::string& s, int startindex, int pointnum){
        if(pointnum==3){
            if(isvalid(s, startindex, s.size()-1)) res.push_back(s);
            return;
        }
        for(int i=startindex; i<s.size(); i++){
            if(isvalid(s, startindex, i)){
                s.insert(s.begin()+i+1, '.');
                pointnum++;
                backtracking(s, i+2, pointnum);
                pointnum--; // 回溯
                s.erase(s.begin()+i+1);
            }
            else break; // 首段不合法，直接结束本层该分支的循环
        }
    }
    bool isvalid(const string& s, int start, int end){
        // 异常
        if(start>end) return false;
        // 开头为0
        if(s[start]=='0' && start!=end) return false;
        int num=0;
        for(int i=start; i<=end; i++){
            // 不在0~9范围内的字符
            if(s[i]>'9' || s[i]<'0') return false;
            num = num*10 + (s[i]-'0');
            // 超出255范围的字符
            if(num>255) return false;
        }
        return true;
    }
    vector<string> restoreIpAddresses(string s) {
        res.clear();
        if(s.size()<4 || s.size()>12) return res;
        backtracking(s, 0, 0);
        return res;
    }

时间复杂度: O(3^4)，IP地址最多包含4个数字，每个数字最多有3种可能的分割方式，则搜索树的最大深度为4，每个节点最多有3个子节点；空间复杂度: O(n)