labuladong的回溯算法的学习

声明：

此文档是基于 labuladong的算法小抄 做的笔记

回溯算法框架：

解决⼀个回溯问题，实际上就是⼀个决 策树的遍历过程
只需要考虑三个问题

1. 路径：也就是已经做出的选择。
2. 选择列表：也就是你当前可以做的选择。
3. 结束条件：也就是到达决策树底层，⽆法再做选择的条件

代码⽅⾯，回溯算法的框架：

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 函数其实就像⼀个指针，在这棵树上游⾛，同时要 正确维护每个节点的属性，每当⾛到树的底层，其「路径」就是⼀个全排 列。

再进⼀步，如何遍历⼀棵树？这个应该不难吧。各种搜索问题其实都是树的遍历问题，⽽多叉树的遍 历框架就是这样：

void traverse(TreeNode root) {
 	for (TreeNode child : root.childern) 
		 // 前序遍历需要的操作 
		 traverse(child); 
		 // 后序遍历需要的操作
 }

前序遍历的代码在进⼊某⼀个节点之前的那个时间点执⾏，后序遍历代码在 离开某个节点之后的那个时间点执⾏。
回想我们刚才说的，「路径」和「选择」是每个节点的属性，函数在树上游 ⾛要正确维护节点的属性，那么就要在这两个特殊时间点搞点动作：

全排列代码：

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();
	}
}

⾄此，我们就通过全排列问题详解了回溯算法的底层原理。当然，这个算法 解决全排列不是很⾼效，应为对链表使⽤ contains ⽅法需要 O(N) 的时间 复杂度。

但是必须说明的是，不管怎么优化，都符合回溯框架，⽽且时间复杂度都不 可能低于 O(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 函数可以将不符合条件的情况剪 枝：

有的时候，我们并不想得到所有合法的答案，只想要⼀个答案，怎么办呢？