【数据结构与算法】-＞算法-＞回溯算法

Ⅰ 前言

在前面讲深度优先搜索算法的时候，我说其实深度优先搜索算法利用的就是回溯算法思想。

【数据结构与算法】-＞算法-＞深度优先搜索&广度优先搜索

这个算法思想非常简单，但是应用非常广泛。它除了用来指导像深度优先搜索算法这种经典的算法设计之外，还可以用在很多实际的软件开发场景中，比如正则表达式匹配、编译原理中的语法分析等。

除此之外，很多经典的数学问题都可以用回溯算法解决，比如数独、八皇后、0-1 背包、图的着色、旅行商问题、全排列等等，我们这篇文章就来讲解一下回溯算法的思想，看看它是如何指导我们解决问题的。

Ⅱ 回溯算法的理解

在我们的一生中，面临着无数次的选择，每个选择就构成了现在的我们。有的人可能做出了现在看来是最正确的选择，有的人则不然。我不喜欢用辉格史观来看历史，但是每个人都可能会想到之前有个选择，选错了，懊恼不已。如果当时做了所谓正确的选择，自己现在也许过得更好。

那我们就来想想，如果人生可以量化，我们要如何才能在岔路口中做出最正确的选择，让自己的人生“最优”呢？

我们可以借助 贪心算法，在每次面对岔路口的时候，都做出看起来是最优的选择，期望这一组选择可以使得我们的人生达到“最优”。但是，在贪心算法的讲解中，我们说过，贪心算法并不一定能得到最优解。那么，有没有什么办法能得到最优解呢？

有一个电影不知道大家有没有看过，叫《蝴蝶效应》。里面的主人公为了达到自己的目标，一直通过回溯的方法，回到童年，在关键的岔路口，重新做选择。当然，这只是个电影，人生无法倒退，但是这个电影其中蕴含的思想就是回溯思想。

笼统地讲，回溯算法很多时候都应用在“搜索”这类问题上，这里的“搜索”并不是狭义的指图的搜索算法，而是在一组可能的解中，搜索满足期望的解。

回溯的处理思想，有点类似枚举搜索。我们枚举所有的解，找到满足期望的解。为了有规律地枚举所有可能的解，避免遗漏和重复，我们把问题求解的过程分为多个阶段，每个阶段我们都会面对一个岔路口。我们先选择一条路走，当发现这条路走不通的时候（不符合期望的解），就回退到上一个岔路口，另选一种走法继续走。

我还是代码来说明。我们先来实现一个回溯的经典例子——八皇后问题。

其实在我很早很早之前的文章里，讲过八皇后问题。当时我是用 C 实现的，并且把它作为递归的例子来讲，这篇文章我们再说一下这个例子，并且聚焦在回溯的思想上。我先把文章链接放在下面，有兴趣的同学可以看看。

【C语言基础】->递归调用->八皇后问题

我们有一个 8×8 的棋盘，希望往里放 8 个棋子（皇后），每个棋子所在的行、列、对角线，都不能有另一个皇后在。如下图中，左图就是符合规则的，右图就不符合规则。

八皇后问题就是期望找到所有满足条件的摆放棋子的方式。

我们把这个问题划分成 8 个阶段，依次将 8 个棋子放到第一行、第二行、…、第八行。在放置的过程中，我们不停地检查当前放法，是否满足要求。如果满足，则跳到下一行继续放置棋子；如果不满足，那就再换一种方法，继续尝试。

回溯算法是非常适合用递归代码实现的，所以，我把八皇后的算法用 Java 写出来，大家可以再对照着看看，如果要看用 C 实现的，可以跳转到我上面链接的文章里去看。

package com.tyz.core;

/**
 * 回溯算法实现八皇后问题
 * @author Tong
 */
public class EightQueens {
	private int[] result = new int[8];

	public EightQueens() {
	}
	
	/**
	 * 递归实现求八皇后的解
	 * @param row
	 */
	public void cal8queens(int row) {
		if (row == 8) {
			printQueens(result); //8个棋子都放置好了
			return;
		}
		for (int column = 0; column < 8; column++) { //每一行有八个位置需要考察
			if (isOk(row, column)) { //检测这个位置是否合法
				result[row] = column; //将row行的元素放在了column列
				cal8queens(row + 1); //这一行棋子放置成功，考察下一行
			}
		}
	}
	
	/**
	 * 检测第row行第column列棋子放置是否合法
	 * @param row
	 * @param column
	 * @return
	 */
	private boolean isOk(int row, int column) {
		int leftUp = column - 1;
		int rightUp = column + 1;
		for (int i = row-1; i >= 0; i--) { //逐行往上考察每一行
			if (result[i] == column) {
				return false;
			}
			if (leftUp >= 0) { //考察左对角线
				if (result[i] == leftUp) {
					return false;
				}
			}
			if (rightUp < 8) { //考察右对角线
				if (result[i] == rightUp) {
					return false;
				}
			}
			leftUp--;
			rightUp--;
		}
		return true;
	}
	
	/**
	 * 打印棋盘
	 * @param result
	 */
	private void printQueens(int[] result) {
		for (int row = 0; row < 8; row++) {
			for (int column = 0; column < 8; column++) {
				if (result[row] == column) {
					System.out.print("Q ");
				} else {
					System.out.print("* ");
				}
			}
			System.out.println();
		}
		System.out.println();
	}
}

测试代码如下👇

package com.tyz.test;

import com.tyz.core.EightQueens;

public class TestFor8queens {

	public static void main(String[] args) {
		EightQueens object = new EightQueens();
		object.cal8queens(0);
	}

}

部分运行结果如下👇

可能有人会疑惑，哪里回溯了呢？我再来分析一下这个回溯的地方。

回溯其实是发生在 22 到 27 行代码中。比如第二行第二列的位置合法，那我们就在这里放一个皇后，这时候执行第 25 行，也就是开始找下一行的放皇后的位置了。

但是在第三行中，找了所有的列，都找不到合法的位置，这时候代码就执行到 27 行，那此次函数调用就执行完了，返回到调用它的地方，即在第二行第二列放入皇后以后，即返回到了第 26 行。然后此时程序会继续执行第 22 行的 for循环的遍历，也就是重新在第二行考察一个合法的位置，第二行如果没有了，那就回溯到第一行去。

这就是程序回溯的经过，大家可以看着代码再思考思考。

Ⅲ 回溯算法的经典应用

这个八皇后的例子，可能你还没有完全清楚回溯思想的实现。我们再通过两个例子来看一下回溯算法的应用和实现。

A. 0-1 背包

0-1 背包是非常经典的算法题，很多场景都可以抽象成这个问题模型。这个问题的经典解法是动态规划，不过还有一种简单但是没有那么高效的解法，那就是我们的回溯算法。

0-1 背包有很多变体，我们这里说一个比较基础的。我们有一个背包，背包总的承载重量是 W kg。我们现在有 n 个物品，每个物品的重量不等，并且不可分割。我们现在期望选择几件物品，装载到背包中。在不超过背包所能装载重量的前提下，如何让背包中物品的总重量最大？

实际上，背包问题在我前面的文章 贪心算法 中，已经说过一个了，不过贪心算法里的物品是可以分割的，我们可以装某个物品的一部分到这个背包里，而 0-1 背包问题，物品是不可分割的，要么装要么不装，所以叫 0-1 背包。显然，这个问题已经无法通过贪心算法来解决了。我们就来看看如何用回溯算法解决这个问题。

对于每个物品来说，都有两种选择，装进背包或者不装进背包，对于 n 个物品来说，总的装法就是 2ⁿ 种，去掉总重量超过 W kg的，从剩下的装法中选择总重量最接近 W kg的。不过我们如何才能不重复地穷举出这 2ⁿ 种装法呢？

这里就可以用到回溯的方法，我们可以把物品依次排列，整个问题就分解成了 n 个阶段，每个阶段对应一个物品怎么选择，先对第一个物品进行处理，选择装进去或者不装进去，然后再递归地处理剩下的物品。我们直接看代码，大家可以对着代码来思考这个逻辑。

package com.tyz.core;

public class ZeroOneBackpack {
	private int maxWeight = Integer.MIN_VALUE;

	public ZeroOneBackpack() {}
	
	/**
	 * 求出不重复的所有解
	 * @param index 当前第index个物品
	 * @param currentWeight 已装进背包的物品重量
	 * @param items 每个物品的重量
	 * @param num 物品个数
	 * @param weight 背包能承受的最大重量
	 * 假设背包可承受重量为 100，物品个数为10，物品重量存储在数组a中
	 * 调用方法：findSolve(0, 0, arr, 10, 100)
	 */
	public void findSolve(int index, int currentWeight, int[] items, 
													int num, int weight) {	
		if (currentWeight == weight || index == num) { //已经装满 || 考察完所有物品
			if (currentWeight > maxWeight) {
				maxWeight = currentWeight;
				return;
			}
		}
		findSolve(index + 1, currentWeight, items, num, weight); //items[index]的物品不装进背包
		if (currentWeight + items[index] <= weight) {
			findSolve(index + 1, currentWeight + items[index], items, num, weight);//装进背包
		}
	}
}

这里的递归代码其实非常复杂，我建议大家如果不理解的话，自己去做一遍变量跟踪，比如设置物品数为 3，背包的重量其实都可以不用管，然后按这个参数来进行变量跟踪，大概就能明白这个算法的原理了。

我在学这里的时候，也是用的物品数为 3，然后做了一遍变量跟踪，用了四页纸。大家可以试试。

这里我尽力说一下这个过程。这几行代码其实实现的是，借助回溯过程，实现了以每一个可能的物品，作为第一个装入背包的，以尝试所有的物品组合。

这四行代码，有人可能会疑惑为什么不用 if else 来写，那其实就不是我们回溯的思想了，我们回溯其实是要面对除了刚才一轮的选项以外所有的选项的，我们要试出每一种结果。

如果做变量跟踪的话，大概就是第一轮每个函数都会调用

findSolve(index + 1, currentWeight, items, num, weight); 

然后层层嵌套，最后到 index = num 那层停下来。然后返回上一轮，试第二种选择。

		if (currentWeight + items[index] <= weight) {
			findSolve(index + 1, currentWeight + items[index], items, num, weight);//装进背包
		}

这时候它又会继续调用 findSolve(index + 1, currentWeight + items[index], items, num, weight，这就相当于再进入下一次，然后尝试下一层的两种选择的配对。

比如我们用 num = 3 开始做变量跟踪的话，我用 1 表示放进背包，0 表示不放进背包，执行一次这个代码，就会得到下面的结果👇

0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1

再次希望大家自己去做一遍变量跟踪，体验一下这个奇妙的过程。

B. 正则表达式

看懂了 0-1 背包，我们再来看另外一个例子，正则表达式匹配。正则表达式再开发中用得非常广泛，而回溯思想其实就是正则表达式里最重要的一种算法思想。

正则表达式中，最重要的就是通配符，通配符结合在一起，可以表达出非常丰富的语义。为了方便讲解，我假设正则表达式中只包含 “ * ” 和 “ ? ” 这两种通配符，并且对这两个通配符的语义稍微做些改变，其中，“ * ” 匹配任意多个（大于等于 0 个）任意字符，“ ? ” 匹配零个或者一个任意字符。基于以上背景假设，我们看下，如何用回溯算法，判断一个给定的文本，能否跟给定的正则表达式匹配。

我们依次考察正则表达式中的每个字符，当是非通配符时，我们就直接跟文本的字符进行匹配，如果相同，则继续往下处理；如果不同，则回溯。

如果我们遇到特殊字符时，我们就有多种处理方式了，也就是所谓的岔路口，比如 “ * ” 有多种匹配方案，可以任意匹配任意个文本串中的字符，我们就先随意地选择一种匹配方案，然后继续考察剩下的字符。如果中途发现无法继续匹配下去了，我们就回到这个岔路口，重新选择一种匹配方案，然后再继续匹配剩下的字符。

我还是直接把代码放出来，其实大家对照着代码，应该就很好理解了。

package com.tyz.core;

public class Pattern {
	private boolean matched;
	private char[] pattern; //正则表达式
	private int plen; //正则表达式长度

	public Pattern() {
		this.matched = false;
	}

	public Pattern(char[] pattern, int plen) {
		this();
		this.pattern = pattern;
		this.plen = plen;
	}
	
	public boolean match(char[] text, int tlen) {
		this.matched = false;
		rmatch(0, 0, text, tlen);
		
		return matched;
	}
	
	private void rmatch(int ti, int pj, char[] text, int tlen) {
		if (matched) {
			return; //已经配对成功
		}
		if (pj == plen) { //正则表达式已经到结尾了
			if (ti == tlen) { //文本串也到结尾了
				matched = true;
			}
			return;
		}
		if (pattern[pj] == '*') { // *匹配任意个字符
			for (int k = 0; k <= tlen-ti; k++) {
				rmatch(ti + k, pj + 1, text, tlen);
			}
		} else if (pattern[pj] == '?') { // ?匹配0个或者1个字符
			rmatch(ti, pj + 1, text, tlen);
			rmatch(ti + 1, pj + 1, text, tlen);
		} else if (ti < tlen && pattern[pj] == text[ti]) {
			rmatch(ti + 1, pj + 1, text, tlen);
		}
	}
}

Ⅳ 总结

回溯算法的思想非常简单，大部分情况下，都是用来解决广义的搜索问题，也就是说，从一组可能的解中，选择出一个满足要求的解。回溯算法非常适合用递归来实现，在实现的过程中，剪枝操作是提高回溯效率的一种技巧。利用剪枝，我们并不需要穷举搜索所有的情况，从而提高搜索效率。

在我们前面做的假设中，人生可量化要怎么求最优解，但是人生当然不可能量化，更不可能回溯。贪心算法给了我们一个很好的启示，件件求最优，最后求得的反而可能不是最优，何况人生不能量化，更做不到超越时间的维度去看自己，所以也选不出来那个件件求最优的选择。我们只能尽可能地了解信息，做出选择，然后承担代价。不要在脑子里做回溯，人生的每一个境地都是我们一个一个的选择堆砌、塑造出来的，我们能做的，只有改变现在的行为，做出选择，然后期待未来有个好结果。