【数据结构与算法】-＞算法-＞动态规划（中）-＞详解动态规划理论

Ⅰ 前言

在上一篇文章中，我通过几个例子讲述了动态规划的思想，这篇文章我们再回到动态规划的基本概念中，带你搞清楚最优子结构，无后效性和重复子问题。

【数据结构与算法】-＞算法-＞动态规划（上）-＞初识动态规划-＞怎么精准地帮助女朋友薅羊毛

Ⅱ 一个模型三个特征

什么样的问题适合用动态规划来解决呢？换句话说，动态规划能解决的问题有什么规律可循呢？实际上，动态规划作为一个非常成熟的算法思想，很多人对此已经做出了非常全面的总结，我下面引述王争老师的总结，把这部分总结为 “一个模型三个特征” 带大家了理解这个概念。

A. 一个模型

首先我们来看什么是 “一个模型”，它指的是动态规划适合解决的问题的模型，我把这个模型定义为 “多阶段决策最优解模型”。

我们一般是用动态规划来解决最优问题。而解决问题的过程，需要经历多个决策阶段。每个决策阶段都对应着一组状态。然后我们寻找一组决策序列，经过这组决策序列，能够产生最终期望求解的最优值。

就像我在前一篇文章里讲的，动态规划其实是开了一个上帝视角，我们把每一个选择同时展开，最终选择一组最优的。

B. 三个特征

一个模型说完了，我们再来看看三个特征：最优子结构、无后效性以及重复子问题。这三个概念比较抽象，我们逐一来看。

1. 最优子结构

最优子结构是指，问题的最优解包含子问题的最优解，反过来说就是，我们可以通过子问题的最优解，推导出问题的最优解。如果我们把最优子结构，对应到我们前面定义的动态规划问题模型上，那我们也可以理解为，后面阶段的状态可以通过前面阶段的状态推导出来。

2. 无后效性

无后效性有两层含义，第一层含义是，在推导后面阶段的状态时候，我们只关心前面阶段的状态值，不关心这个状态是怎么一步一步推导出来的。第二次含义是，某阶段状态一旦确定，就不受之后阶段的决策影响。无后效性是一个非常“宽松”的要求。只要满足前面提到的动态规划问题模型，其实基本上都会满足无后效性。

3. 重复子问题

用一句话概括一下，就是，不同的决策序列，到达某个相同的阶段时，可能会产生重复的状态。

Ⅲ 一个特征三个模型实例解析

大家可能看了前面的概念，觉得还是没有完全理解。我就来通过一个具体的动态规划问题，来做一个更详尽的解释。

假设我们有一个 n 乘以 n 的矩阵 w[n][n]。矩阵存储的都是正整数，棋子起始位置从=在左上角，终止位置在右下角，会有很多不同的路径可以走。我们把每条路径经过的数字加起来看作路径的长度。那从左上角移动到右下角的最短路径长度是多少呢？

我们先来看看，这个问题是否符合“一个模型”。

从 (0, 0) 走到 (n-1, n-1)，总共要走 2*(n-1) 步，也就对应着 2*(n-1) 个阶段。每个阶段都有向右走或者向下走两种决策，并且每个阶段都会对应一个状态集合。

我们把状态定义为 min_dist(i, j)，其中 i 表示行，j 表示列。min_dist 表示最短路径长度。所以，这个问题是一个多阶段决策最优解问题，符合动态规划的模型。

我们再来看看，这个问题是否符合“三个特征”。

我们可以用回溯法来解决这个问题。如果你画一下这个代码实现的递归树，就会发现，递归树中有很多重复的节点。重复的节点表示，从左上角到节点对应的位置，有多种路线，这也能说明这个问题中存在重复子问题。

如果我们走到 (i, j) 这个位置，我们只能通过 (i-1, j)，(i, j-1) 这两个位置移动过来，也就是说，我们想要计算 (i, j) 位置对应的状态，只需要关心 (i-1, j)，(i, j-1) 两个位置对应的状态，并不关心棋子是通过什么样的路线到达这两个位置的。而且，我们仅仅允许往下和往右移动，不允许后退，所以，前面阶段的状态确定以后，不会被后面阶段的决策所改变。所以，这个问题符合 “无后效性” 这一特征。

定义状态的时候，我们把从起始位置 (0, 0) 到 (i, j) 的最小路径，记作 min_dist(i, j)。因为我们只能往右或往下移动，所以，我们只有可能从 (i, j-1) 或者 (i-1, j) 这两个位置到达 (i, j) 。也就是说，到达 (i, j) 的最短路径要么经过 (i, j-1) ，要么经过 (i-1, j)，而且到达 (i, j) 的最短路径肯定包含到达这两个位置的最短路径之一。换句话说就是，min_dist(i, j) 可以通过 min_dist(i, j-1) 和 min_dist(i-1, j) 两个状态推导出来。这就说明，这个问题符合 “最优子结构”
。

大家可以思考一下这个逻辑。

Ⅳ 两种动态规划解题思路总结

前面我们讲了如何去鉴别一个问题是否可以用动态规划来解决，现在，我们再来看一下动态规划解题的一般思路，让你面对动态规划问题的时候，能够有章可循。

解决动态规划问题，一般有两种思路。我们分别称为状态转移表法 和 状态转移方程法。

A. 状态转移表法

一般能用动态规划解决的问题，都可以使用回溯算法的暴力搜索解决。所以，当我们拿到问题的时候，我们可以先用简单的回溯算法解决，然后定义状态，每个状态表示一个节点，然后对应画出递归树。从递归树中，我们很容易可以看出来，是否存在重复子问题，以及重复子问题是如何产生的。以此来寻找规律，看是否能用动态规划解决。

找到重复子问题之后，接下来，我们有两种处理思路，第一种是直接用回溯加“备忘录” 的方法，来避免重复子问题。从执行效率上来讲，这跟动态规划的解决思路没有差别。第二种是使用动态规划的解决方法，状态转移表法。我们主要来看看状态转移表法是如何工作的，回溯法的例子就不再赘述了。

我们先画出一个状态表，状态表一般都是二维的，所以你可以将它理解成一个二维数组。其中，每个状态包含三个变量，行、列、数组值。我们根据决策的先后过程，从前往后，根据递推关系，分阶段填充状态表中的每个状态，最后，再将这个递推填表的过程，翻译成代码，这就是动态规划的代码了。

尽管大部分状态表都是二维的，但是如果问题的状态比较复杂，需要很多变量来表示，那对应的状态表可能就是高维的，比如三维、四维。那这个时候，我们就不适合用状态转移表来解决了。一方面因为高位状态转移图不好画出来，一方面是因为多维数组是比较反人类的日常思维模式的，很难去想出来。

现在，我们就来看一下，如何套用这个状态转移表法，来解决前面那个矩阵求最短路径的问题。

从起点到终点，我们有很多种不同的走法，我们可以穷举所有的走法，然后对比找出一个最短走法。不过，如何才能无重复又不遗漏地穷举出所有的走法呢？我们可以用回溯算法这个比较有规律的穷举算法。

回溯算法的代码实现如下👇

package com.tyz.second.core;

public class MatrixMinDistance {
	private int minDist = Integer.MAX_VALUE;
	
	public MatrixMinDistance() {}
	
	/**
	 * 回溯法求二维矩阵的两点最短路径
	 * @param i 行下标
	 * @param j 列下标
	 * @param dist (0, 0)到(i, i)的最短路径
	 * @param matrix 要查找的二维数组
	 * @param n 行列数
	 */
	public void minDistBT(int i, int j, int dist, int[][] matrix, int n) {
		if (i == n-1 && j == n-1) {
			if (dist < minDist) {
				minDist = dist;
				return;
			}
		}
		if (i < n) {
			minDistBT(i + 1, j, dist + matrix[i][j], matrix, n);
		}
		if (j < n) {
			minDistBT(i, j + 1, dist + matrix[i][j], matrix, n);
		}
	}

}

有了回溯代码之后，我们可以画出递归树了，以此来寻找重复子问题。在递归树中，一个状态（也就是一个节点）包含三个变量 (i, j, dist)，其中 i，j 分别表示行和列，dist 表示从起点到达 (i, j) 的路径长度。从图中，我们看出，尽管 (i, j, dist) 不存在重复的，但是 (i, j) 重复的很多。对于 (i, j) 重复的节点，我们只需要选择 dist 最小的节点，继续递归求解，其他节点就可以舍弃了。

既然存在重复子问题，我们就可以尝试看下，是否可以用动态规划来解决。

我们画出一个二维状态表，表中的行、列表示棋子所在的位置，表中的数值表示从起点到这个位置的最短路径。我们按照决策过程，通过不断状态递推演进，将状态表填好。为了方便代码实现，我们按行来进行依次填充。

弄懂了填表的过程，代码的实现就很容易了。我们将上面的过程，翻译成代码。

package com.tyz.second.core;

/**
 * 动态规划求二维矩阵(0, 0)到(n, n)的距离
 * @author Tong
 */
public class MinDistDP {

	public MinDistDP() {
	}
	
	/**
	 * @param matrix 在matrix矩阵中求两点直间的最短路径
	 * @param n 二维矩阵行列数
	 * @return 最短路径
	 */
	public int minDistDP(int[][] matrix, int n) {
		int[][] states = new int[n][n];
		int rowSum = 0;
		int colSum = 0;
		
		//填states第一列和第一行的值
		for (int i = 0; i < n; i++) {
			rowSum += matrix[i][0];
			states[i][0] = rowSum;
			
			colSum += matrix[0][i];
			states[0][i] = colSum;
		}
		//动态规划
		for (int i = 1; i < n; i++) {
			for (int j = 1; j < n; j++) {
				states[i][j] = matrix[i][j] + Math.min(states[i][j-1], states[i-1][j]);
			}
		}
		
		return states[n-1][n-1];
	}

}

B. 状态转移方程法

状态转移方程法有点类似递归的解题思路。我们需要分析，某个问题如何通过子问题来递归求解，也就是所谓的最优子结构。根据最优子结构，写出递归公式，也就是所谓的状态转移方程。有了状态转移方程，代码就简单多了。一般情况下，我们有两种代码实现方法。一种是递归加“备忘录”，另一种是迭代递推。

我们还是用上面的例子来讲，最优子结构前面我们已经分析过了，我将状态转移方程给出。

状态转移方程是解决动态规划的关键。 如果我们能写出状态转移方程，那动态规划问题基本上就解决了一半，翻译代码也不会很难。但是很多动态规划问题的状态本身就不好定义，状态转移方程也就更不好想到。

下面我用递归加 “备忘录” 的方式，来实现这个代码。大家可以做个参考。对于另一种实现方法，其实和状态转移法的代码是一样的，只是思路不同。

package com.tyz.second.core;

/**
 * 动态规划求二维矩阵(0, 0)到(n, n)的最短路径
 * 动态转移方程法-递归加备忘录实现
 * @author Tong
 */
public class MinDist {
	private int[][] matrix = {
			{1, 3, 5, 9},
			{2, 1, 3, 4},
			{5, 2, 6, 7},
			{6, 8, 4, 3}
	};
	private int n = 4;
	private int[][] mem = new int[n][n];
	
	public MinDist() {}

	/**
	 * 动态转移方程法-递归加备忘录实现二维数组求最短路径
	 * 调用 minDist(n-1, n-1)
	 * @param i 行下标
	 * @param j 列下标
	 * @return 最短路径
	 */
	public int minDist(int i, int j) {
		if (i == 0 && j == 0) {
			return matrix[0][0];
		}
		if (mem[i][j] > 0) { //备忘录，已经计算过这个位置的最短路径了，不需要再做计算了
			return mem[i][j];
		}
		
		int minLeft = Integer.MAX_VALUE;
		if (j-1 >= 0) {
			minLeft = minDist(i, j - 1);
		}
		
		int minUp = Integer.MAX_VALUE;
		if (i-1 >= 0) {
			minUp = minDist(i - 1, j);
		}
		
		int curMinDist = matrix[i][j] + Math.min(minLeft, minUp);
		mem[i][j] = curMinDist; //如果是不同路径中的同一个位置的元素，取其最短的路径
		
		return curMinDist;
	}
}

以上就是动态规划解题的两种思路，不是每个问题都同时适合这两种解题思路，大家要结合具体的题目来分析。

Ⅴ 四种算法思想比较分析

在前面的几篇文章中，我一共讲了四种算法思想：贪心算法，分治算法，回溯算法以及动态规划。我们就来比较一下这四种算法，找找它们之间的共性和差异。

【数据结构与算法】-＞算法-＞贪心算法

【数据结构与算法】-＞算法-＞分治算法

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

【数据结构与算法】-＞算法-＞动态规划（上）

如果我们将这四种算法思想分一下类，那贪心、回溯、动态规划可以归为一类，而分治单独作为一类，因为它和其他三个都不太一样，前三个算法解决问题的模型，都可以抽象成我们这篇文章说的多阶段决策最优解模型，而分治算法解决的问题尽管大部分也是最优解问题，但是，大部分都不嫩被抽象成多阶段决策最优解模型。

回溯算法是个万金油，基本上能用动态规划、贪心解决的问题，我们都可以用回溯算法解决。回溯算法相当于穷举搜索。穷举所有的情况，然后对比得到最优解。不过，回溯算法的时间复杂度非常高，是指数级别的，只能用来解决小规模数据的问题。对于大规模数据的问题，用回溯算法解决的效率就很低了。

尽管动态规划比回溯算法高效，但是，并不是所有问题，都可以用动态规划来解决。能用动态规划解决的问题，需要满足三个特征：最优子结构、无后效性和重复子问题。

贪心算法实际上是动态规划算法的一种特殊情况。它解决问题起来更加高效，代码实现也更加简洁。不过它可以解决的问题也更加有限。它能解决的问题需要满足三个条件：最优子结构，无后效性和贪心选择性。这里我们不是很在乎重复子问题。

其中，最优子结构、无后效性跟动态规划中的无异。贪心选择性，意思是，通过局部最优的选择，能产生全局的最优的选择。每一个阶段，我们都选择当前看起来最优的决策，所有阶段的决策完成之后，最终由这些局部最优解构成全局最优解。

Ⅵ 小总结

两种动态规划的解题思路：状态转移表法和状态转移方程法。

状态转移表法解题思路：回溯算法实现 --> 定义状态 --> 画递归树 --> 找重复子问题 --> 画状态转移表 --> 根据递推关系填表 --> 将填表过程翻译成代码 。

状态转移方程法解题思路：找最优子结构 --> 写状态转移方程 --> 将状态转移方程翻译成代码。

关于动态规划更进一步的内容，可以跳转去看我下面的文章👇

【数据结构与算法】-＞算法-＞动态规划（下）-＞如何实现搜索引擎的拼写纠错功能？