备注：这篇笔记是极客时间中王争的《数据结构与算法》动态规划章节的学习笔记。
算法主要包括贪心、回溯、动态规划和分治算法四种，动态规划的核心本质是以空间换时间，记录每一个子问题的最优解，进而达到提升计算效率的目的。
可解决的问题
什么样的问题适合用动态规划来解决呢？换句话说，动态规划能解决的问题有什么规律可循呢？实际上，简单总结就是“一个模型三个特征”。
什么是“一个模型”？它指的是动态规划适合解决的问题的模型。我把这个模型定义为“多阶段决策最优解模型”。
我们一般是用动态规划来解决最优问题。而解决问题的过程，需要经历多个决策阶段。每个决策阶段都对应着一组状态。然后我们寻找一组决策序列，经过这组决策序列，能够产生最终期望求解的最优值。
“三个特征”分别是指最优子结构、无后效性和重复子问题。
- 最优子结构指的是，问题的最优解包含子问题的最优解。反过来说就是，我们可以通过子问题的最优解，推导出问题的最优解。如果我们把最优子结构，对应到我们前面定义的动态规划问题模型上，那我们也可以理解为，后面阶段的状态可以通过前面阶段的状态推导出来。
- 无后效性有两层含义，第一层含义是，在推导后面阶段的状态的时候，我们只关心前面阶段的状态值，不关心这个状态是怎么一步一步推导出来的。第二层含义是，某阶段状态一旦确定，就不受之后阶段的决策影响。无后效性是一个非常“宽松”的要求。只要满足前面提到的动态规划问题模型，其实基本上都会满足无后效性。
- 重复子问题这个概念比较好理解。前面一节，我已经多次提过。如果用一句话概括一下，那就是，不同的决策序列，到达某个相同的阶段时，可能会产生重复的状态。
解题思路
解决动态规划问题，一般有两种思路。我把它们分别叫作，状态转移表法和状态转移方程法。
一：状态转移表法
简单说就是用数组记录状态，空间换时间。
一般能用动态规划解决的问题，都可以使用回溯算法的暴力搜索解决。所以，当我们拿到问题的时候，我们可以先用简单的回溯算法解决，然后定义状态，每个状态表示一个节点，然后对应画出递归树。从递归树中，我们很容易可以看出来，是否存在重复子问题，以及重复子问题是如何产生的。以此来寻找规律，看是否能用动态规划解决。
找到重复子问题之后，接下来，我们有两种处理思路，第一种是直接用 回溯加“备忘录” 的方法(也就是加状态记录的回溯算法)，来避免重复子问题。从执行效率上来讲，这跟动态规划的解决思路没有差别。第二种是使用动态规划的解决方法，状态转移表法。
我们重点来看状态转移表法是如何工作的。
我们先画出一个状态表。状态表一般都是二维的，所以你可以把它想象成二维数组。其中，每个状态包含三个变量，行、列、数组值。我们根据决策的先后过程，从前往后，根据递推关系，分阶段填充状态表中的每个状态。最后，我们将这个递推填表的过程，翻译成代码，就是动态规划代码了。
尽管大部分状态表都是二维的，但是如果问题的状态比较复杂，需要很多变量来表示，那对应的状态表可能就是高维的，比如三维、四维。那这个时候，我们就不适合用状态转移表法来解决了。一方面是因为高维状态转移表不好画图表示，另一方面是因为人脑确实很不擅长思考高维的东西。(一般不会遇到，先不考虑这个场景)
二：状态转移方程法
状态转移方程法有点类似递归的解题思路。我们需要分析，某个问题如何通过子问题来递归求解，也就是所谓的最优子结构。根据最优子结构，写出递归公式，也就是所谓的状态转移方程。有了状态转移方程，代码实现就非常简单了。一般情况下，我们有两种代码实现方法，一种是递归加“备忘录”，另一种是迭代递推。
我们还是拿刚才的例子来举例。最优子结构前面已经分析过了，你可以回过头去再看下。为了方便你查看，我把状态转移方程放到这里。
min_dist(i, j) = w[i][j] + min(min_dist(i, j-1), min_dist(i-1, j))
这里我强调一下，状态转移方程是解决动态规划的关键。如果我们能写出状态转移方程，那动态规划问题基本上就解决一大半了，而翻译成代码非常简单。但是很多动态规划问题的状态本身就不好定义，状态转移方程也就更不好想到。
下面我用递归加“备忘录”的方式，将状态转移方程翻译成来代码，你可以看看。对于另一种实现方式，跟状态转移表法的代码实现是一样的，只是思路不同。
我要强调一点，不是每个问题都同时适合这两种解题思路。有的问题可能用第一种思路更清晰，而有的问题可能用第二种思路更清晰，所以，你要结合具体的题目来看，到底选择用哪种解题思路。
案例
0-1背包问题
问题描述
0-1背包是经典问题
有n 个物品，它们有各自的重量和价值，现有给定容量的背包，如何让背包里装入的物品具有最大的价值总和？
包含元素：物品的重量、物品的价值、背包的容量。
属于最优化问题，可以使用回溯法+“备忘录”的方法，也可以使用动态规划的方法。
问题分析
根据分析可知，这个问题是多阶段的最优解问题，其中各个步骤有重复子问题
我们还是照例画出递归树。在递归树中，每个节点表示一个状态。现在我们需要 3 个变量（i, cw, cv）来表示一个状态。其中，i 表示即将要决策第 i 个物品是否装入背包，cw 表示当前背包中物品的总重量，cv 表示当前背包中物品的总价值。
我们发现，在递归树中，有几个节点的 i 和 cw 是完全相同的，比如 f(2,2,4) 和 f(2,2,3)。在背包中物品总重量一样的情况下，f(2,2,4) 这种状态对应的物品总价值更大，我们可以舍弃 f(2,2,3) 这种状态，只需要沿着 f(2,2,4) 这条决策路线继续往下决策就可以。
所以，构建“备忘录”为一个n * (w + 1)的二维数组，n是物品的个数，w是背包的容积，多一个值是背包重量为0的情况。
备注：上图是只有物品重量的情况下，如果包含物品价值元素，求最大价值时候，数组的值是当前的最大价值。
代码
/**
* 使用动态规划方法实现0-1背包问题
* 背包约束条件：物品价格，物品重量，最大物品个数，背包容量
* @param items,物品重量清单
* @param values，物品价值清单
* @param w，背包容积
* @return
*/
public int knapsack2(int[] items, int[] values, int w) {
// 思路：遍历每一个元素，记录选择这个元素和不选择这个元素的价值差多少
// 使用一个n * (w + 1)的二维数组作为备忘录，
int n = items.length;
if (n <= 0){
return 0;
}
// 设置初始值
int[][] mem = new int[n][w + 1];
for(int i = 0; i < n ; i ++){
for(int j = 0; j <= w; j ++){
mem[i][j] = -1;
}
}
// 设置哨兵，没有放置元素的情况下，重量为0
mem[0][0] = 0;
// 需要先设置初始值，用于后续记录的前置判断，先看第一个元素是否要放置进去
if(items[0] <= w){
mem[0][items[0]] = values[0];
}
//从第1行开始记录
for(int i = 1; i < n; i ++){
// 第i个元素不放置的情况
for(int j = 0;j <= w; j ++){
if(mem[i - 1][j] >= 0){
mem[i][j] = mem[i - 1][j];
}
}
// 第i个元素放置的情况
for (int j = 0; j <= w - items[i]; j++){
if(mem[i - 1][j] >= 0){
int v = mem[i - 1][j] + values[i];
// 选择i元素后的价值，大于对应重量下标的价值
if(v > mem[i][j + items[i]]){
mem[i][j + items[i]] = v;
}
}
}
}
// 当最后一个元素判断完之后，选取出最终的最大价值
int max_v = -1;
for(int i = w ; i >= 0;i --){
if(mem[n -1][i] > max_v){
max_v = mem[n -1][i];
}
}
return max_v;
}
最短路径问题
问题描述
假设我们有一个 n 乘以 n 的矩阵 w[n][n]。矩阵存储的都是正整数。棋子起始位置在左上角，终止位置在右下角。我们将棋子从左上角移动到右下角。每次只能向右或者向下移动一位。从左上角到右下角，会有很多不同的路径可以走。我们把每条路径经过的数字加起来看作路径的长度。那从左上角移动到右下角的最短路径长度是多少呢？
问题分析
分析问题的递进过程，划分不同的计算阶段，看是否符合动态规划的特征。
递归树如下图所示
代码
使用状态转移表法，均使用“备忘录”方式，记录历史子问题最优结果。
- 使用迭代方法
/**
* 最短路径问题：Shortest Path
* 查找二维数组中起始节点到最终节点的最短路径
* 状态转移方程是： min_dist(i,j) = items[i,j] + min(min_dist(i - 1,j),min_dist(i, j - 1))
*/
public int shortestPathByIteration(int[][] items){
if (items.length <= 0){
return 0;
}
int[][] mem = new int[items.length][items[0].length];
// 对mem数组进行初始化
mem[0][0] = items[0][0];
for(int i = 1; i < items.length; i ++){
mem[i][0] = items[i][0] + mem[i - 1][0];
}
for(int j = 1; j < items[0].length; j ++){
mem[0][j] = items[0][j] + mem[0][j - 1];
}
// 使用状态转移表法，迭代方式进行计算
for(int i = 1; i < mem.length; i ++){
for(int j = 1; j < mem[0].length; j ++){
mem[i][j] = items[i][j] + Math.min(mem[i-1][j],mem[i][j-1]);
}
}
return mem[items.length - 1][items[0].length - 1];
}
- 使用递归方法
/***
* 状态转移方程是： min_dist(i,j) = items[i,j] + min(min_dist(i - 1,j),min_dist(i, j - 1))
* 使用递归+“备忘录”方式(记录状态的数组)
*/
private int shortestPathByRecursion(int[][] items){
if (items.length <= 0){
return 0;
}
int[][] mem = new int[items.length][items[0].length];
// 设置哨兵
mem[0][0] = items[0][0];
return minDist(items.length - 1,items[0].length - 1,items,mem);
}
private int minDist(int row,int col,int[][] items,int[][] mem){
// 从最终节点遍历只起始节点
if(row == 0 && col == 0){
return items[0][0];
}
// 当前位置已经计算过，直接取结果（重复子问题）
if (mem[row][col] > 0){
return mem[row][col];
}
int left = Integer.MAX_VALUE;
int up = Integer.MAX_VALUE;
// 递归找到左侧元素的最短距离
if(row - 1 >= 0){
left = minDist(row - 1,col,items,mem);
}
if(col - 1 >= 0){
up = minDist(row,col - 1,items,mem);
}
// 使用最大整型，规避了边缘元素的判断问题
int currDist = items[row][col] + Math.min(left,up);
mem[row][col] = currDist;
return currDist;
}
四种算法思想比较分析
到今天为止，我们已经学习了四种算法思想，贪心、分治、回溯和动态规划。今天的内容主要讲些理论知识，我正好一块儿也分析一下这四种算法，看看它们之间有什么区别和联系。
如果我们将这四种算法思想分一下类，那贪心、回溯、动态规划可以归为一类，而分治单独可以作为一类，因为它跟其他三个都不大一样。为什么这么说呢？前三个算法解决问题的模型，都可以抽象成我们今天讲的那个多阶段决策最优解模型，而分治算法解决的问题尽管大部分也是最优解问题，但是，大部分都不能抽象成多阶段决策模型。
回溯算法是个“万金油”。基本上能用的动态规划、贪心解决的问题，我们都可以用回溯算法解决。回溯算法相当于穷举搜索。穷举所有的情况，然后对比得到最优解。不过，回溯算法的时间复杂度非常高，是指数级别的，只能用来解决小规模数据的问题。对于大规模数据的问题，用回溯算法解决的执行效率就很低了。
尽管动态规划比回溯算法高效，但是，并不是所有问题，都可以用动态规划来解决。能用动态规划解决的问题，需要满足三个特征，最优子结构、无后效性和重复子问题。在重复子问题这一点上，动态规划和分治算法的区分非常明显。分治算法要求分割成的子问题，不能有重复子问题，而动态规划正好相反，动态规划之所以高效，就是因为回溯算法实现中存在大量的重复子问题。
贪心算法实际上是动态规划算法的一种特殊情况。它解决问题起来更加高效，代码实现也更加简洁。不过，它可以解决的问题也更加有限。它能解决的问题需要满足三个条件，最优子结构、无后效性和贪心选择性（这里我们不怎么强调重复子问题）。
其中，最优子结构、无后效性跟动态规划中的无异。“贪心选择性”的意思是，通过局部最优的选择，能产生全局的最优选择。每一个阶段，我们都选择当前看起来最优的决策，所有阶段的决策完成之后，最终由这些局部最优解构成全局最优解。
总结
当我们拿到一个问题的时候，我们可以先不思考，计算机会如何实现这个问题，而是单纯考虑“人脑”会如何去解决这个问题。人脑比较倾向于思考具象化的、摸得着看得见的东西，不适合思考过于抽象的问题。所以，我们需要把抽象问题具象化。那如何具象化呢？我们可以实例化几个测试数据，通过人脑去分析具体实例的解，然后总结规律，再尝试套用学过的算法，看是否能够解决。
