动态规划的递归写法和递推写法详解

互联网的猫

于 2024-06-15 23:26:51 发布

阅读量728

点赞数 15

分类专栏：动态规划算法专题文章标签：动态规划算法数据结构 c++

本文链接：https://blog.csdn.net/m0_72674633/article/details/139707395

版权

动态规划算法专题专栏收录该内容

10 篇文章 0 订阅

订阅专栏

动态规划的概念

动态规划的递归写法

动态规划的递推写法

动态规划的概念

动态规划是一种用来解决一类最优化问题的算法思想。简单来说，动态规划将一个复杂的问题分解成若干个子问题，通过综合子问题的最优解来得到原问题的最优解。需要注意的是，动态规划会将每个求解过的子问题的解记录下来，这样当下一次碰到同样的子问题时，就可以直接使用之前记录的结果，而不是重复计算。注意：虽然动态规划采用这种方式来提高计算效率，但不能说这种做法就是动态规划的核心。

动态规划的递归写法

以斐波那契数列为例，斐波那契数列的定义为 $F_{0}=1,F_{1}=1,F_{n}=F_{n-1}+F_{n-2}\left ( n\geqslant 2 \right )$

int F(int n){
	if(n==0||n==1){
		return 1;
	}
	else{
		return F(n-1)+F(n-2);
	}
}

为了避免重复计算，可以开一个一维数组dp，用以保存已经计算过的结果，其中dp[n]记录F(n)的结果，并用dp[n]==-1表示F(n)当前还没有被计算过。

int dp[maxn];

然后就可以在递归当中判断dp[n]是否为-1：如果不是-1，说明已经计算过F(n)，直接返回dp[n]就是结果；否则，按照递归式进行递归。代码如下：

int F(int n){
	if(n==0||n==1){
		return 1;
	}
	if(dp[n]!=-1){
		return dp[n];
	}
	else{
		dp[n]=F(n-1)+F(n-2);
		return dp[n];
	}
}

这样就把已经计算过的内容记录下来，于是当下次再碰到需要计算相同的内容时，就能直接使用上次计算的结果，这可以省去大半无效计算，而这也是记忆化搜索这个名字的由来。

通过上面的例子可以引申出一个概念：如果一个问题可以被分解为若干个子问题，且这些子问题会重复出现，那么就称这个问题拥有重叠子问题。动态规划通过记录重叠子问题的解，来使下次碰到相同的子问题时直接使用之前记录的结果，以此避免大量重复计算。因此，一个问题必须拥有重叠子问题，才能使用动态规划去解决。

动态规划的递推写法

以经典的数塔问题为例，将一些数字排成数塔的形状，其中第一层有一个数字，第二层有两个数字…第n层有n个数字。现在要从第一层走到第n层，每次只能走向下一层连接的两个数字中的一个，问：最后将路径上所有数字相加后得到的和最大是多少？

针对这个问题，枚举的话时间复杂度太高。不妨令dp[i][j]表示第i行第j个数字出发的到达最底层的所有路径中能得到的最大和。在定义这个数组之后，dp[1][1]就是最终想要的答案。

同时，我们可以考虑到如果要求出dp[i][j]，那么一定要先求出它的两个子问题“从位置(i+1,j)到达最底层的最大和dp[i+1][j]”和"从位置(i+1,j+1)到达最底层的最大和dp[i+1][j+1]“，即进行了一次决策：走位置(i,j)的左下还是右下。于是dp[i][j]就是dp[i+1][j]和dp[i+1][j+1]的较大值加上f[i][j]。写成式子就是： $dp[i][j]=max\left ( dp[i+1][j], dp[i+1][j+1]\right )+f[i][j]$ .

把dp[i][j]称为问题的状态，而把上面的式子称作状态转移方程，它把状态dp[i][j]转移为dp[i+1][j]和dp[i+1][j+1]。可以发现，状态dp[i][j]只与第i+1层的状态有关，而与其他层的状态无关，这样层号为i的状态总是可以由层号为i+1的两个子状态得到。那么，如果总是将层号增大可以发现数塔的最后一层的dp值总是等于元素本身，即dp[n][j]=f[n][j]，把这种可以直接确定其结果的部分称为边界，而动态规划的递推写法总是从这些边界出发，通过状态转移方程扩散到整个dp数组。

这样就可以从最底层各位置的dp值开始，不断往上求出每一层各位置的dp值，最后就得到dp[1][1]，即为最后得到的答案。

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1000;
int f[maxn][maxn],dp[maxn][maxn];
int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=i;j++){
			cin>>f[i][j];
		}
	}
	for(int j=1;j<=n;j++){
		dp[n][j]=f[n][j];
	}
	for(int i=n-1;i>=1;i--){
		for(int j=1;j<=i;j++){
			dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+f[i][j];
		}
	}
	cout<<dp[1][1]<<endl;
	return 0;
}

显然使用递归也可以实现上面的例子（即从dp[1][1]开始递归，直至到达边界时返回结果）。两者的区别在于：使用递推写法的计算方式是自底向上，即从边界开始，不断向上解决问题，直到解决了目标问题；而使用递归写法的计算方式是自顶向下，即从目标问题开始，将它分解成子问题的组合，直到分解至边界为止。

通过上面的例子再引申出一个概念：如果一个问题的最优解可以由其子问题的最优解有效地构造出来，那么称这个问题拥有最优子结构。最优子结构保证了动态规划中原问题的最优解可以由子问题的最优解推导出来。因此，一个问题必须拥有最优子结构才能够使用动态规划求解。

下面指出两个概念的区别：

（1）分治与动态规划。分治和动态规划都是将问题分解为子问题，然后合并子问题的解得到原问题的解。但是不同的是，分治法分解出的子问题是不重叠的，因此分治法解决的问题不拥有重叠子问题，而动态规划解决的问题拥有重叠子问题。另外，分治法解决的问题不一定是最优化问题，而动态规划解决的问题一定是最优化问题。

（2）贪心与动态规划。贪心和动态规划都要求原问题必须拥有最优子结构。二者的区别在于，贪心法采用的计算方式类似于上面介绍的”自顶向下“，但是并不等待子问题求解完毕后再选择使用哪一个，而是通过一种策略直接选择一个子问题去求解，没被选择的子问题就不去求解了，直接抛弃。也就是说，它总是只在上一步选择的基础上继续选择，因此整个过程以一种单链的流水方式进行，显然这种所谓“最优选择”的正确性需要用归纳法证明。而动态规划不管是自底向上还是自顶向下的计算方式，都是从边界开始向上得到目标问题的解。也就是说，它总是会考虑所有子问题，并选择继承能得到最优结果的那个，对暂时没被继承的子问题，由于重叠子问题的存在，后期可能会再次考虑它们，因此还有机会成为全局最优的一部分，不需要放弃。所以贪心是一种壮士断腕的决策，只要进行了选择，就不后悔；动态规划则要看哪个选择笑到了最后，暂时的领先说明了什么。