回溯算法详解
解决⼀个回溯问题，实际上就是⼀个决策树的遍历过程。你只需要思考 3 个问题：
1、路径：也就是已经做出的选择。
2、选择列表：也就是你当前可以做的选择。
3、结束条件：也就是到达决策树底层，⽆法再做选择的条件。
如果你不理解这三个词语的解释，没关系，我们后⾯会⽤「全排列」和「N 皇后问题」这两个经典的回溯算法问题来帮你理解这些词语是什么意思。
代码⽅⾯，回溯算法的框架：
result = []
def backtrack(路径, 选择列表):
if 满足结束条件:
result.add(路径)
return
for 选择 in 选择列表:
做选择
backtrack(路径, 选择列表)
撤销选择
其核⼼就是 for 循环⾥⾯的递归，在递归调⽤之前「做选择」，在递归调⽤之后「撤销选择」。
《全排列问题》--- 主要是让你明⽩什么是「做选择」
我们在⾼中的时候就做过排列组合的数学题，我们也知道 n 个不重复的 数，全排列共有 n! 个
PS：为了简单清晰起⻅，我们这次讨论的全排列问题不包含重复的数字。
那么我们当时是怎么穷举全排列的呢？⽐⽅说给三个数 [1,2,3] ，你肯定 不会⽆规律地乱穷举，⼀般是这样：
先固定第⼀位为 1，然后第⼆位可以是 2，那么第三位只能是 3；然后可以把第⼆位变成 3，第三位就只能是 2 了；然后就只能变化第⼀位，变成 2， 然后再穷举后两位…… 其实这就是回溯算法，或者有的同学直接画出如 下这棵回溯树：
只要从根遍历这棵树，记录路径上的数字，其实就是所有的全排列。我们不妨把这棵树称为回溯算法的「决策树」，为啥说这是决策树呢，因为你在每个节点上其实都在做决策。⽐如说你站在下图的红⾊节点上：
你现在就在做决策，可以选择 1 那条树枝，也可以选择 3 那条树枝。为啥只 能在 1 和 3 之中选择呢？因为 2 这个树枝在你⾝后，这个选择你之前做过了，⽽全排列是不允许重复使⽤数字的；
现在可以解答开头的⼏个名词： [2] 就是「路径」，记录你已经做过的选 择； [1,3] 就是「选择列表」，表⽰你当前可以做出的选择；「结束条件」就是遍历到树的底层，在这⾥就是选择列表为空的时候。
如果明⽩了这⼏个名词，可以把「路径」和「选择」列表作为决策树上每个 节点的属性，⽐如下图列出了⼏个节点的属性：
我们定义的 backtrack 函数其实就像⼀个指针，在这棵树上游⾛，同时要正确维护每个节点的属性，每当⾛到树的底层，其「路径」就是⼀个全排列。 ⽽所谓的前序遍历和后序遍历，他们只是两个很有⽤的时间点，画图你就明⽩了：
前序遍历的代码在进⼊某⼀个节点之前的那个时间点执⾏，后序遍历代码在 离开某个节点之后的那个时间点执⾏。 回想我们刚才说的，「路径」和「选择」是每个节点的属性，函数在树上游⾛要正确维护节点的属性，那么就要在这两个特殊时间点搞点动作：
我们只要在递归之前做出选择，在递归之后撤销刚才的选择，就能正确得到每个节点的选择列表和路径。 下⾯，直接看全排列代码：
List<List<Integer>> res = new LinkedList<>();
/* 主函数，输⼊⼀组不重复的数字，返回它们的全排列 */
List<List<Integer>> permute(int[] nums) {
// 记录「路径」
LinkedList<Integer> track = new LinkedList<>();
backtrack(nums, track);
return res;
}
// 路径：记录在 track 中
// 选择列表：nums 中不存在于 track 的那些元素
// 结束条件：nums 中的元素全都在 track 中出现
void backtrack(int[] nums, LinkedList<Integer> track) {
// 触发结束条件
if (track.size() == nums.length) {
res.add(new LinkedList(track));
return;
}
for (int i = 0; i < nums.length; i++) {
// 排除不合法的选择
if (track.contains(nums[i]))
continue;
// 做选择
track.add(nums[i]);
// 进⼊下⼀层决策树
backtrack(nums, track);
// 取消选择
track.removeLast();
}
}
}我们这⾥稍微做了些变通，没有显式记录「选择列表」，⽽是通过 nums 和 track 推导出当前的选择列表：
⾄此，我们就通过全排列问题详解了回溯算法的底层原理。当然，这个算法 解决全排列不是很⾼效，应为对链表使⽤ contains ⽅法需要 O(N) 的时间 复杂度。有更好的⽅法通过交换元素达到⽬的，但是难理解⼀些，这⾥就不写了。 但是必须说明的是，不管怎么优化，都符合回溯框架，⽽且时间复杂度都不可能低于 O(N!)，因为穷举整棵决策树是⽆法避免的。这也是回溯算法的⼀ 个特点，不像动态规划存在重叠⼦问题可以优化，回溯算法就是纯暴⼒穷举，复杂度⼀般都很⾼。 明⽩了全排列问题，就可以直接套回溯算法框架了，下⾯简单看看 N 皇后 问题。
《N 皇后问题》
这个问题很经典了，简单解释⼀下：给你⼀个 N×N 的棋盘，让你放置 N 个 皇后，使得它们不能互相攻击。
PS：皇后可以攻击同⼀⾏、同⼀列、左上左下右上右下四个⽅向的任意单 位。 这个问题本质上跟全排列问题差不多，决策树的每⼀层表⽰棋盘上的每⼀ ⾏；每个节点可以做出的选择是，在该⾏的任意⼀列放置⼀个皇后。 直接套⽤框架:
vector<vector<string>> res;
/* 输⼊棋盘边⻓ n，返回所有合法的放置 */
vector<vector<string>> solveNQueens(int n) {
// '.' 表⽰空，'Q' 表⽰皇后，初始化空棋盘。
vector<string> board (n, string(n, '.'));
backtrack(board, 0);
return res;
}
// 路径：board 中⼩于 row 的那些⾏都已经成功放置了皇后
// 选择列表：第 row ⾏的所有列都是放置皇后的选择
// 结束条件：row 超过 board 的最后⼀⾏
void backtrack(vector<string>&board, int row) {
// 触发结束条件
if (row == board.size()) {
res.push_back(board);
return;
}
int n = board[row].size();
for (int col = 0; col < n; col++) {
// 排除不合法选择
if (!isValid(board, row, col))
continue;
// 做选择
board[row][col] = 'Q';
// 进⼊下⼀⾏决策
backtrack(board, row + 1);
// 撤销选择
board[row][col] = '.';
}
} 这部分主要代码，其实跟全排列问题差不多， isValid 函数的实现也很简单：
/* 是否可以在 board[row][col] 放置皇后？ */
bool isValid(vector<string>&board, int row, int col) {
int n = board.size();
// 检查列是否有皇后互相冲突
for (int i = 0; i < n; i++) {
if (board[i][col] == 'Q')
return false;
}
// 检查右上⽅是否有皇后互相冲突
for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
if (board[i][j] == 'Q')
return false;
}
// 检查左上⽅是否有皇后互相冲突
for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
if (board[i][j] == 'Q')
return false;
}
return true;
}
函数 backtrack 依然像个在决策树上游⾛的指针，通过 row 和 col 就可 以表⽰函数遍历到的位置，通过 isValid 函数可以将不符合条件的情况剪枝：
如果直接给你这么⼀⼤段解法代码，可能是懵逼的。但是现在明⽩了回溯算法的框架套路，还有啥难理解的呢？⽆⾮是改改做选择的⽅式，排除不合法 选择的⽅式⽽已，只要框架存于⼼，你⾯对的只剩下⼩问题了。
当 N = 8 时，就是⼋皇后问题，数学⼤佬⾼斯穷尽⼀⽣都没有数清楚⼋皇 后问题到底有⼏种可能的放置⽅法，但是我们的算法只需要⼀秒就可以算出 来所有可能的结果。
不过真的不怪⾼斯。这个问题的复杂度确实⾮常⾼，看看我们的决策树，虽 然有 isValid 函数剪枝，但是最坏时间复杂度仍然是 O(N^(N+1))，⽽且⽆ 法优化。如果 N = 10 的时候，计算就已经很耗时了。 有的时候，我们并不想得到所有合法的答案，只想要⼀个答案，怎么办呢？
⽐如解数独的算法，找所有解法复杂度太⾼，只要找到⼀种解法就可以。 其实特别简单，只要稍微修改⼀下回溯算法的代码即可：
// 函数找到⼀个答案后就返回true
bool backtrack(vector<string>&board, int row) {
// 触发结束条件
if (row == board.size()) {
res.push_back(board);
return true;
}
...
for (int col = 0; col < n; col++) {
...
board[row][col] = 'Q';
if (backtrack(board, row + 1))
return true;
board[row][col] = '.';
}
return false;
} 这样修改后，只要找到⼀个答案，for 循环的后续递归穷举都会被阻断。
总结
回溯算法就是个多叉树的遍历问题，关键就是在前序遍历和后序遍历的位置 做⼀些操作，算法框架如下：
def backtrack(...):
for 选择 in 选择列表:
做选择
backtrack(...)
撤销选择
写 backtrack 函数时，需要维护⾛过的「路径」和当前可以做的「选择列表」，当触发「结束条件」时，将「路径」记⼊结果集。 其
实想想看，回溯算法和动态规划是不是有点像呢？动态规划的三个需要明确的点就是「状态」「选择」和 「base case」，是不是就对应着⾛过的「路径」，当前的「选择列表」和 「结束条件」？
某种程度上说，动态规划的暴⼒求解阶段就是回溯算法。只是有的问题具有 重叠⼦问题性质，可以⽤ dp table 或者备忘录优化，将递归树⼤幅剪枝，这就变成了动态规划。⽽今天的两个问题，都没有重叠⼦问题，也就是回溯算法问题了，复杂度⾮常⾼是不可避免的。
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
本文内容来源----公众号：labuladong [《labuladong的算法小抄》](https://pan.baidu.com/s/1opAj7nFDY5wnWmv16Ss6Yw) 提取码：g9l2
扫一扫
477
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
