| 关卡名 | 继续看回溯问题 | 我会了✔️ |
| 内容 | 1.复习递归和N叉树，理解相关代码是如何实现的 | ✔️ |
| 2.理解回溯到底怎么回事 | ✔️ | |
| 3.掌握如何使用回溯来解决二叉树的路径问题 | ✔️ |
1 复原IP地址
这也是一个经典的分割类型的回溯问题。LeetCode93.有效IP地址正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。
例如："0.1.2.201" 和 "192.168.1.1" 是有效 IP 地址，但是 "0. 011. 255 .245"、"192.168.1.312" 和 "192.168@1.1" 是无效IP地址。给定一个只包含数字的字符串s，用以表示一个IP地址，返回所有可能的有效IP地址，这些地址可以通过在s中插入 '.' 来形成。你不能重新排序或删除s中的任何数字。你可以按任何顺序返回答案。
示例1：
输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]
该问题的思路与与前面的分割回文串基本一致，也是切割问题。回溯的第一步就是使用枚举将所有可能性搜出来,找到一个符合要求的就先切下来，后面的部分继续进行枚举和切割，如果到了最后发现不符合要求，则开始回溯。
本题的难度明显比上一题要大，主要是判断是否合法的要求更高了，比如第一个元素我们可以截取2、25、255、2552，很显然到了2552之后就不合法了，此时就要回溯。后面也一样，假如我们第一层截取的是2，第二层就从”5525511135“中截取，此时可以有5，55，552，显然552已经不合法了，依次类推。画出图来就如下所示：
当然这里还要判断是0的情况等等，在字符串转换成数字一章，我们讲解了很多种要处理的情况，为此我们可以写一个方法单独来执行相关的判断。代码如下：
// 判断字符串s在左闭⼜闭区间[start, end]所组成的数字是否合法
private Boolean isValid(String s, int start, int end) {
if (start > end) {
return false;
}
// 0开头的数字不合法
if (s.charAt(start) == '0' && start != end) {
return false;
}
int num = 0;
for (int i = start; i <= end; i++) {
// 遇到⾮数字字符不合法
if (s.charAt(i) > '9' || s.charAt(i) < '0') {
return false;
}
num = num * 10 + (s.charAt(i) - '0');
if (num > 255) { // 如果⼤于255了不合法
return false;
}
}
return true;
}另外，IP地址只有四段，不是无限分割的，因此本题只会明确的分成4段，不能多也不能少。所以不能用切割线切到最后作为终止条件，而是分割的段数到了4就必须终止。考虑到我们构造IP地址时还要手动给添加三个小数点，所以我们用变量pointNum来表示小数点数量，pointNum为3说明字符串分成了4段了。
要手动添加一个小数点，这要增加一个位置来存储，所以下一层递归的startIndex要从i+2开始。其他的主要工作就是递归和回溯的过程了。这里的撤销部分要注意将刚刚加入的分隔符删掉，并且pointNum也要-1，完整代码如下：
class RestoreIpAddresses {
List<String> result = new ArrayList<>();
public List<String> restoreIpAddresses(String s) {
//这个是IP的特性决定的
if (s.length()<4||s.length() > 12)
return result;
backTrack(s, 0, 0);
return result;
}
// startIndex: 搜索的起始位置， pointNum:添加小数点的数量
private void backTrack(String s, int startIndex, int pointNum) {
if (pointNum == 3) {// 小数点数量为3时，分隔结束
// 判断第四段⼦字符串是否合法，如果合法就放进result中
if (isValid(s,startIndex,s.length()-1)) {
result.add(s);
}
return;
}
for (int i = startIndex; i < s.length(); i++) {
if (isValid(s, startIndex, i)) {
//在str的后⾯插⼊⼀个小数点
s = s.substring(0, i + 1) + "." + s.substring(i + 1);
pointNum++;
// 插⼊小数点之后下⼀个⼦串的起始位置为i+2
backTrack(s, i + 2, pointNum);
pointNum--;// 撤销操作
s = s.substring(0, i + 1) + s.substring(i + 2);//撤销操作
} else {
break;
}
}
}
}2 电话号码问题
LeetCode17.电话号码组合问题，也是热度非常高的一个题目，给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 给出数字到字母的映射如下(与电话按键相同)。注意 1 不对应任何字母，9对应四个字母。
示例1：
输入：digits = "2| 3 4567"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
我们说回溯仍然会存在暴力枚举的情况，这个题就很典型，例如如果输入23，那么，2就有 a、b、c三种情况，3有d、e、f三种情况。组合一下就一共就有3*3=9种，如果是233，那么就是27种。
这里要注意的9对应4个字母，而1则没有，那该怎么建立字母和数字之间的映射呢？我们用一个数组来保存，而不写一堆的if else。而为了保证遍历时index也恰好与数组的索引一致，我们按照如下的方式来定义数组：
String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
接下来我们就用回溯来解决n层循环的问题，输入23对应的树就是这样的：
树的深度就是输入的数字个数，例如输入23，树的深度就是2。而所有的叶子节点就是我们需要的结果["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]。所以这里的终止条件就是，如果当前执行的index 等于输入的数字个数（digits.size）了。
使用for循环来枚举出来，然后循环体内就是回溯过程了。基本实现过程如下：
class LetterCombinations {
List<String> list = new ArrayList<>();
public List<String> letterCombinations(String digits) {
if (digits == null || digits.length() == 0) {
return list;
}
//初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""
String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
backTracking(digits, numString, 0);
return list;
}
//每次迭代获取一个字符串，所以会设计大量的字符串拼接，所以这里选择更为高效的 StringBuild
StringBuilder temp = new StringBuilder();
//比如digits如果为"23",num 为0，则str表示2对应的 abc
public void backTracking(String digits, String[] numString, int num) {
//遍历全部一次记录一次得到的字符串
if (num == digits.length()) {
list.add(temp.toString());
return;
}
//str 表示当前num对应的字符串
String str = numString[digits.charAt(num) - '0'];
for (int i = 0; i < str.length(); i++) {
temp.append(str.charAt(i));
backTracking(digits, numString, num + 1);
//剔除末尾的继续尝试
temp.deleteCharAt(temp.length() - 1);
}
}
}3 括号生成问题
本题是一道非常典型的回溯问题，LeetCode22.数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
示例1：
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]
要解决该问题，我们首先要明确一个问题，左右括号什么时候可以获得。我们知道左括号出现的数量一定等于n，观察题目给的示例，只要剩余左括号的数量大于0，就可以添加"("，例如"("、"(()"、”(()(“、”()((“都是可以的，因为我们只要再给加几个右括号就行，例如可以将其变成"()"、"(())"、”(()()“、”()(())“。
那添加右括号的要求呢？结论是：序列中左括号的数量必须大于右括号的数量，例如上面的"("、"(()"、”(()(“、”()((“，都可以，但是如果")"、"())"、”)()(“、”()((“就不可以了，此时的情况都是右括号数量大于等于左括号。所以我们可以得到两条结论：
- 1.只要剩余左括号的数量大于0，就可以添加"("。
- 2.序列中左括号的数量必须大于右括号的数量才可以添加"("，并且")"的剩余数量大于0。
接下来看如何用回溯解决，我们将添加"("视为left，将")"视为right，这样"("和")"各可以出现n次。我们以n=2为例画一下的图示：
图中红叉标记的位置是左括号大于有括号了，不能再向下走了，这个操作也称为剪枝。通过图示，可以得到如下结论：
- 当前左右括号都有大于 0 个可以使用的时候，才产生分支，否则就直接停止。
- 产生左分支的时候，只看当前是否还有左括号可以使用；
- 产生右分支的时候，除了要求还有右括号，还要求剩余右括号数量一定大于左括号的数量；
- 在左边和右边剩余的括号数都等于 0 的时候结束。
而且，从上图可以看到，不管是剪枝还是得到一个结果，返回的过程仍然可以通过回溯来实现：
class GenerateParenthesis {
public List<String> generateParenthesis(int n) {
List<String> ans = new ArrayList<String>();
backtrack(ans, new StringBuilder(), 0, 0, n);
return ans;
}
/**
* @param ans 当前递归得到的结果
* @param cur 当前的括号串
* @param open 左括号已经使用的个数
* @param close 右括号已经使用的个数
* @param max 序列长度最大值
*/
public void backtrack(List<String> ans, StringBuilder cur, int open, int close, int max) {
if (cur.length() == max * 2) {
ans.add(cur.toString());
return;
}
//本题需要两次回溯，比较少见的情况
if (open < max) {
cur.append('(');
backtrack(ans, cur, open + 1, close, max);
cur.deleteCharAt(cur.length() - 1);
}
if (close < open) {
cur.append(')');
backtrack(ans, cur, open, close + 1, max);
cur.deleteCharAt(cur.length() - 1);
}
}
}
![【C++入门到精通】 线程库 | thread类 C++11 [ C++入门 ]](https://img-blog.csdnimg.cn/direct/cc54c76d53ef401cb7aab0ccdd65ab56.png#pic_center)
