logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

【动态规划理论】：一篇文章带你彻底搞懂最优子结构、无后效性和重复子问题

 我是皮卡丘 2021-12-22

上一节，我通过两个非常的问题，向你展示了用动态规划问题的过程。今天主要讲一些理论知识。学完这节内容，可以帮你解决这几个问题：什么样的问题可以用动态规划来解决？解决动态规划问题的一般思路是什么？贪心、分治、回溯、动态规划这四种算法思想又有什么区别和联系。

“一个模型三个特征”理论的讲解

动态规划作为一个非常成熟的算法思想，很多人对此做了非常全面的总结，我把这部分理论总结为“一个模型三个特征”。

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

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

“三个特征”，分别是最优子结构、无后效性和重复子问题。这三个概念比较抽象，逐一解释一下。

1、最优子结构

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

2、无后效性

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

3、重复子问题

这个概念，前面一节，已经多次提到。用一句话概括就是： 不同的决策序列，到达某个相同的阶段时，可能会产生重复的状态。

“一个模型三个特征”实例剖析

“一个模型三个特征”这部分理论知识，比较抽象，你看了之后可能还是有点懵，有种似懂非懂的感觉，没关系，这个很正常。接下来，我结合一个具体的动态规划问题，来详细解释下。

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

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

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

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

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

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

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

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

min_dis(i, j) = w[i][j] + min(min_dis(i, j-1), min_dis(i-1, j))

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

刚刚讲过，如何鉴别一个问题是否可以用动态规划来解决。现在，我再总结一下，动态规划解题的一般思路，让你面对动态规划问题的时候，能够有章可循，不至于束手无策。

我个人觉得，解决动态规划问题，一般有两种思路。我把它们分别叫作，状态转移表法和状态转移方程法。

1、状态转移表法

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

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

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

尽管大部分表都是二维的，但是如果问题的状态比较复杂，需要很多变量来表示，那对应的状态可能就是高维的，比如三维、四维。那这个时候，我们就不适合用状态转移表法来解决了。一方面是因为高维状态转移表不好画图表示，另一方面因为人脑确实很不擅长思考高维的东西。

现在，看一下，如何用状态转移表法，来解决那矩阵最短路径的问题？

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

回溯算法的代码实现如下

  1. int minDist = INT_MAX;
  3. // 调用方式：minDistBacktracing(0, 0, w[0][0], w, n);
  4. void minDistBT(int i, int j, int dist, vector<vector<int>> &w, int n) {
  5. 	//到达了 n-1, n-1 这个位置了
  6. 	if (i == n-1 && j == n-1 ) {
  7. 		if (dist < minDist) {
  8. 			minDist = dist;
  9. 		}
  10. 		return;
  11. 	}
  13. 	if (i < n-1) {//往下走，更新i=i+1, j=j
  14. 		minDistBT(i + 1, j, dist + w[i+1][j], w, n);
  15. 	}
  17. 	if (j < n-1) { // 往右走，更新 i=i, j=j+1
  18. 		minDistBT(i, j + 1, dist + w[i][j+1], w, n);
  19. 	}
  20. }

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

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

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

将上面的过程，翻译成代码，就是下面这个样子

  1. int minDistDP(const vector<vector<int>> &matrix, int n) {
  2. 	vector<vector<int>> states;
  3. 	int sum = 0;
  4. 	for (int j = 0; j < n; ++j) {//初始化states的第一列数据
  5. 		sum += matrix[0][j];
  6. 		states[0][j] = sum;
  7. 	}
  9. 	sum = 0;
  10. 	for (int i = 0; i < n; ++i) { //初始化states的第一行数据
  11. 		sum += matrix[i][0];
  12. 		states[i][0] = sum;
  13. 	}
  15. 	for (int i = 1; i < n; ++i) {
  16. 		for (int j = 1; j < n; ++j) {
  17. 			states[i][j] = matrix[i][j] + min(states[i - 1][j], states[i][j - 1]);
  18. 		}
  19. 	}
  21. 	return states[n - 1][n - 1];
  22. }

2，状态转移方程法

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

我们还是拿刚才的例子来举例。最优子结构前面已经分析过了，你可以回过头去再看下。为了方便你查看，我把状态转移方程放到这里。

min_dist(i, j) = w[i][j] + min(min_dist(i, j-1), min_dist(i-1, j))

这里我强调一下，状态转移方程是解决动态规划的关键。如果我们能写出状态转移方程，那动态规划问题基本上就解决一大半了，而翻译成代码非常简单。但是很多动态规划问题的状态本身就不好定义，状态转移方程也就更不好想到。

下面我用递归加“备忘录”的方式，将状态转移方程翻译成来代码，你可以看看。对于另一种实现方式，跟状态转移表法的代码实现是一样的，只是思路不同。

  1. //状态转移方程min_dist(i, j) = w[i][j] + min(min_dist(i, j-1), min_dist(i-1, j))
  2. vector<vector<int>> matrix({ { 1, 3, 5, 9 },{ 2, 1, 3, 4 },{ 5, 2, 6, 7 },{ 6, 8, 4, 3 } });
  3. int n = 4;
  4. vector<vector<int>> mem(4, vector<int>(4)); //备忘录
  6. int minDist(int i, int j) {//调用minDist(n-1,n-1)
  7. 	if (i == 0 && j == 0) return matrix[0][0];
  8. 	if (mem[i][j] > 0) return mem[i][j];
  10. 	int minLeft = INT_MAX;
  11. 	if (j - 1 >= 0) {
  12. 		minLeft = minDist(i, j - 1);
  13. 	}
  15. 	int minUp = INT_MAX;
  16. 	if (i - 1 >= 0) {
  17. 		minUp = minDist(i - 1, j);
  18. 	}
  20. 	int curMinDIst = matrix[i][j] + min(minLeft, minUp);
  21. 	mem[i][j] = curMinDIst;
  22. 	return curMinDIst;
  23. }

两种动态规划解题思路到这里就讲完了。我要强调一点，不是每个问题都同时适合这两种解题思路。有的问题可能用第一种思路更清晰，而有的问题可能用第二种思路更清晰，所以，你要结合具体的题目来看，到底选择用哪种解题思路。

四种算法思想比较分析

到今天为止，我们已经学习了四种算法思想，贪心、分治、回溯和动态规划。今天的内容主要讲些理论知识，我正好一块儿也分析一下这四种算法，看看它们之间有什么区别和联系。

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

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

尽管动态规划比回溯算法高效，但是，并不是所有问题，都可以用动态规划来解决。能用动态规划解决的问题，需要满足三个特征，最优子结构、无后效性和重复子问题。在重复子问题这一点上，动态规划和分治算法的区分非常明显。分治算法要求分割成的子问题，不能有重复子问题，而动态规划正好相反，动态规划之所以高效，就是因为回溯算法实现中存在大量的重复子问题。

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

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

内容小结

今天的内容到此就讲完了，我带你来复习一下。

我首先讲了什么样的问题适合用动态规划解决。这些问题可以总结概括为“一个模型三个特征”。其中，“一个模型”指的是，问题可以抽象成分阶段决策最优解模型。“三个特征”指的是最优子节、无后效性和重复子问题。

然后，我讲了两种动态规划的解题思路。它们分别是状态转移表法和状态转移方程法。其中，状态转移表法解题思路大致可以概括为，回溯算法实现 - 定义状态 - 画递归树 - 找重复子问题 - 画状态转移表 - 根据递推关系填表 - 将填表过程翻译成代码。状态转移方程法的大致思路可以概括为，找最优子结构 - 写状态转移方程 - 将状态转移方程翻译成代码。

最后，我们对比了之前讲过的四种算法思想。贪心、回溯、动态规划可以解决的问题模型类似，都可以抽象成多阶段决策最优解模型。尽管分治算法也能解决最优问题，但是大部分问题的背景都不适合抽象成多阶段决策模型。

今天的内容比较偏理论，可能会不好理解。很多理论知识的学习，单纯的填鸭式讲给你听，实际上效果并不好。要想真的把这些理论知识理解透，化为己用，还是需要你自己多思考，多练习。等你做了足够多的题目之后，自然就能自己悟出一些东西，这样再回过头来看理论，就会非常容易看懂。

所以，在今天的内容中，如果有哪些地方你还不能理解，那也没关系，先放一放。下一节，我会运用今天讲到的理论，再解决几个动态规划的问题。等你学完下一节，可以再回过头来看下今天的理论知识，可能就会有一种顿悟的感觉。

课后思考

硬币找零问题，我们在贪心算法那一节中讲过一次。我们今天来看一个新的硬币找零问题。假设我们有几种不同币值的硬币 v1，v2，……，vn（单位是元）。如果我们要支付 w 元，求最少需要多少个硬币。比如，我们有 3 种不同的硬币，1 元、3 元、5 元，我们要支付 9 元，最少需要 3 个硬币（3 个 3 元的硬币）。

可以看做爬阶梯问题，分别可以走1.3.5步，怎么最少走到9步，动态转移方程为f(9)=1+min(f(8),f(6),f(4))

  1. //递归加备忘录实现动态规划
  2. int Recu_Get_Min_Coil(vector<int> &items, vector<int> &record, int result_money) {
  3. 	if (record[result_money] != -1) return record[result_money];
  5. 	priority_queue<int, vector<int>, greater<int>> mpq;
  7. 	for (auto a : items) {
  8. 		int temp = result_money - a;
  9. 		if (temp > 0) {
  10. 			mpq.push(Recu_Get_Min_Coil(items, record, temp)+1);
  11. 		}
  12. 	}
  14. 	int result = mpq.top();
  15. 	record[result] = result;
  16. 	return result;
  17. }
  19. int Get_Min_Coil(vector<int> &items, int result_money) {
  20. 	if (items.empty()) return -1;
  22. 	if (result_money < 1) return -1;
  24. 	vector<int> record(result_money+1, -1); //record[i]保存支付i元至少需要多少硬币
  25. 	for (auto a : items) {
  26. 		if (a <= result_money) {
  27. 			record[a] = 1;
  28. 		}
  29. 	}
  31. 	int result = Recu_Get_Min_Coil(items, record, result_money);
  32. 	return result;
  33. }
  35. //用迭代来实现，动态规划
  36. int Get_Min_Coil_2(vector<int> &items, int result_money) {
  37. 	if (items.empty()) return -1;
  39. 	if (result_money < 1) return -1;
  41. 	//先计算最多使用多少个硬币（前提是当前钱数用最小钱币一定能支付，实际情况就是这样）
  42. 	int maxcoil = result_money / items[0];
  43. 	//行代表已使用的硬币数，列代表已经支付了多少钱，元素值表示该状态是否存在
  44. 	vector<vector<bool>> record( maxcoil+1, vector<bool>(result_money + 1, false) );
  46. 	//对第一层单独处理
  47. 	for (auto a : items) {
  48. 		if (a <= result_money) {
  49. 			record[1][a] = true;
  50. 		}
  51. 	}
  53. 	//填充第2行到maxcoil行
  54. 	for (int i = 2; i < maxcoil + 1; i++) {
  55. 		for (int j = 1; j < result_money + 1; j++) {
  56. 			if (record[i-1][j] == true) {
  57. 				for (auto a : items) {
  58. 					if (j + a <= result_money) {
  59. 						record[i][j + a] = true;
  60. 					}
  61. 				}
  62. 			}
  63. 		}
  64. 	}
  66. 	//找出最小硬币数
  67. 	for (int i = 1; i <= maxcoil; i++) {
  68. 		if (record[i][result_money] == true) {
  69. 			return i;
  70. 		}
  71. 	}
  73. 	return -1;
  74. }
  77. // application
  78. int main()
  79. {
  80. 	vector<int> items{ 1,3,5 };
  81. 	cout << 'result=' << Get_Min_Coil(items, 11); //3
  82. 	cout << 'result=' << Get_Min_Coil_2(items, 11); //3
  84. 	//return 0;
  85. 	system('pause');
  86. }

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 我是皮卡丘 > 《待分类》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多