1.回溯算法.基础

1.回溯算法

基础知识
题目
- 1.组合
- 2.组合-优化
- 3.组合总和|||
- 4.电话号码和字母组合
- 5.组合总和
- 6.组合总和II
- 7.分割回文串
- 8.复原IP地址

基础知识

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

回溯算法能解决的问题：

组合问题：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;// 开头为0if(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;}