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;
// 开头为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)
