动态规划问题

最新推荐文章于 2024-07-13 16:30:23 发布

SJLin96

最新推荐文章于 2024-07-13 16:30:23 发布

阅读量470

点赞数

分类专栏：数据结构与算法

本文链接：https://blog.csdn.net/weixin_39731083/article/details/81302272

版权

数据结构与算法专栏收录该内容

16 篇文章 3 订阅

订阅专栏

一. 从一个例子入门

题目：在下面的数字三角形中寻找一条从顶部到底边的路径，使得路径上所经过的数字之和最大。路径上的每一步都只能往左下或右下走。只需要求出这个最大和即可，不必给出具体路径。三角形的行数大于1小于等于100，数字为 0~99。（此题目来源于北大POJ）

输入格式：

5 //表示三角形的行数接下来输入三角形

3 8

8 1 0

2 7 4 4

4 5 2 6 5

1、第一次解题：递归解法

首先，肯定得用二维数组来存放数字三角形

然后我们用D( r, j) 来表示第r行第 j 个数字(r，j从1开始算)

我们用MaxSum(r, j)表示从D(r,j)到底边的各条路径中，最佳路径的数字之和。

因此，此题的最终问题就变成了求 MaxSum(1,1)

当我们看到这个题目的时候，首先想到的就是可以用简单的递归来解题：

D(r, j)出发，下一步只能走D(r+1,j)或者D(r+1, j+1)。故对于N行的三角形，我们可以写出如下的递归式：

if ( r == N)                
	MaxSum(r,j) = D(r,j)  
else      
	MaxSum( r, j) = Max{ MaxSum(r＋1,j), MaxSum(r+1,j+1) } + D(r,j)

根据上面这个简单的递归式，我们就可以很轻松地写出完整的递归代码：

#include <iostream>  
#include <algorithm> 
#define MAX 101  
using namespace std; 
int D[MAX][MAX];  
int n;  
int MaxSum(int i, int j){    
	if(i==n)  
		return D[i][j];    
	int x = MaxSum(i+1,j);    
	int y = MaxSum(i+1,j+1);    
	return max(x,y)+D[i][j];  
}
int main(){    
	int i,j;    
	cin >> n;    
	for(i=1;i<=n;i++)   
		for(j=1;j<=i;j++)        
			cin >> D[i][j];    
	cout << MaxSum(1,1) << endl;  
}

对于如上这段递归的代码，当提交到POJ时，会显示如下结果：

对的，代码运行超时了，为什么会超时呢？

答案很简单，因为我们重复计算了，当我们在进行递归时，计算机帮我们计算的过程如下图：

就拿第三行数字1来说，当我们计算从第2行的数字3开始的MaxSum时会计算出从1开始的MaxSum，当我们计算从第二行的数字8开始的MaxSum的时候又会计算一次从1开始的MaxSum，也就是说有重复计算。这样就浪费了大量的时间。也就是说如果采用递规的方法，深度遍历每条路径，存在大量重复计算。则时间复杂度为 2的n次方,对于 n = 100 行，肯定超时。

2、第二次解题：递归解法改进

接下来，我们就要考虑如何进行改进，我们自然而然就可以想到如果每算出一个MaxSum(r,j)就保存起来，下次用到其值的时候直接取用，则可免去重复计算。那么可以用n方的时间复杂度完成计算。因为三角形的数字总数是 n(n+1)/2

根据这个思路，我们就可以将上面的代码进行改进，使之成为记忆递归型的动态规划程序：

#include <iostream>  
#include <algorithm> 
using namespace std;
 
#define MAX 101
  
int D[MAX][MAX];    
int n;  
int maxSum[MAX][MAX];
 
int MaxSum(int i, int j){      
	if( maxSum[i][j] != -1 )         
		return maxSum[i][j];      
	if(i==n)   
		maxSum[i][j] = D[i][j];     
	else{    
		int x = MaxSum(i+1,j);       
		int y = MaxSum(i+1,j+1);       
		maxSum[i][j] = max(x,y)+ D[i][j];     
	}     
	return maxSum[i][j]; 
} 
int main(){    
	int i,j;    
	cin >> n;    
	for(i=1;i<=n;i++)   
		for(j=1;j<=i;j++) {       
			cin >> D[i][j];       
			maxSum[i][j] = -1;   
		}    
	cout << MaxSum(1,1) << endl; 
}

当我们提交如上代码时，结果就是一次AC：

3、第三次解题：递推解法

虽然在短时间内就AC了。但是，我们并不能满足于这样的代码，因为递归总是需要使用大量堆栈上的空间，很容易造成栈溢出，我们现在就要考虑如何把递归转换为递推，让我们一步一步来完成这个过程。

我们首先需要计算的是最后一行，因此可以把最后一行直接写出，如下图：

现在开始分析倒数第二行的每一个数，现分析数字2，2可以和最后一行4相加，也可以和最后一行的5相加，但是很显然和5相加要更大一点，结果为7，我们此时就可以将7保存起来，然后分析数字7，7可以和最后一行的5相加，也可以和最后一行的2相加，很显然和5相加更大，结果为12，因此我们将12保存起来。以此类推。。我们可以得到下面这张图：

然后按同样的道理分析倒数第三行和倒数第四行，最后分析第一行，我们可以依次得到如下结果：

上面的推导过程相信大家不难理解，理解之后我们就可以写出如下的递推型动态规划程序：

#include <iostream>  
#include <algorithm> 
using namespace std; 
 
#define MAX 101  
 
int D[MAX][MAX];   
int n;  
int maxSum[MAX][MAX]; 
int main(){    
	int i,j;    
	cin >> n;    
	for(i=1;i<=n;i++)   
		for(j=1;j<=i;j++)        
			cin >> D[i][j];   
	for( int i = 1;i <= n; ++ i )     
		maxSum[n][i] = D[n][i];   
	for( int i = n-1; i>= 1;  --i )     
		for( int j = 1; j <= i; ++j )         
			maxSum[i][j] = max(maxSum[i+1][j],maxSum[i+1][j+1]) + D[i][j];    
	cout << maxSum[1][1] << endl;  
}

二. 什么是动态规划

下面就可以来总结一下什么是动态规划了：

动态规划即Dynamic Programming，简称DP。从本质上来看动态规划问题，最核心的思想就是将一个大的问题拆分成一个一个的子问题，通过定义问题与子问题之间的状态转移关系，从而使得问题可以递推的解决下去。（绝大部分递归的问题都可以用动态规划的方式来解决，而且可以大大减小时间复杂度和空间复杂度）

动态规划问题是面试题中的热门话题，如果要求一个问题的最优解（通常是最大值或者最小值），而且该问题能够分解成若干个子问题，并且小问题之间也存在重叠的子问题，则考虑采用动态规划。

可使用动态规划求解的题目特征：
①求一个问题的最优解
②大问题可以分解为子问题，子问题还有重叠的更小的子问题
③整体问题最优解取决于子问题的最优解（状态转移方程）
④从上往下分析问题，从下往上解决问题
⑤讨论底层的边界问题

1. 将原问题分解为子问题

把原问题分解为若干个子问题，子问题和原问题形式相同或类似，只不过规模变小了。子问题都解决，原问题即解决(数字三角形例）。
子问题的解一旦求出就会被保存，所以每个子问题只需求解一次。

2. 确定状态

在用动态规划解题时，我们往往将和子问题相关的各个变量的一组取值，称之为一个“状态”。一个“状态”对应于一个或多个子问题，所谓某个“状态”下的“值”，就是这个“状态”所对应的子问题的解。
所有“状态”的集合，构成问题的“状态空间”。“状态空间”的大小，与用动态规划解决问题的时间复杂度直接相关。在数字三角形的例子里，一共有N×(N+1)/2个数字，所以这个问题的状态空间里一共就有N×(N+1)/2个状态。
整个问题的时间复杂度是状态数目乘以计算每个状态所需时间。在数字三角形里每个“状态”只需要经过一次，且在每个状态上作计算所花的时间都是和N无关的常数。

3. 确定一些初始状态（边界状态）的值

以“数字三角形”为例，初始状态就是底边数字，值就是底边数字值。

4. 确定状态转移方程

定义出什么是“状态”，以及在该“状态”下的“值”后，就要找出不同的状态之间如何迁移――即如何从一个或多个“值”已知的 “状态”，求出另一个“状态”的“值”(递推型)。状态的迁移可以用递推公式表示，此递推公式也可被称作“状态转移方程”。

数字三角形的状态转移方程:

下面会再收集一些可用动态规划来求解的题目，加强练习

三. 硬币找零问题

1. 问题描述

给定一组硬币数，找出一组最少的硬币数，来找换零钱N。

比如，可用来找零的硬币为: 1、3、4 待找的钱数为 6。用两个面值为3的硬币找零，最少硬币数为2。而不是 4，1，1

2. 动态规划求解分析

考虑该问题的最优子结构：设 c[j,i]表示可用第 0，1，.... j 枚硬币对金额为 i 的钱进行找钱所需要的最少硬币数。
j表示可用的硬币种类数， i表示需要找回的零钱
第 j 枚硬币有两种选择：用它来找零和不用它找零。因此，c[j,i]的最优解如下：
c[j,i]= min{c[j-1,i] , c[j, i-coinsValues[j]] + 1} 其中，
c[j-1,i] 表示不使用第 j 枚硬币找零时，对金额为 i 进行找钱所需要的最少硬币数
c[j, i-coinsValues[j]] + 1 表示使用第 j 枚硬币找零时，对金额为 i 进行找钱所需要的最少硬币数。由于用了第 j 枚硬币，故使用的硬币数量要增1
c[j,i] 取二者的较小值的那一个。
由上面的分析可知，其实就是从1块钱开始找零，找到i块钱。并每次把最小找零数目存储起来，方便后面调用。

3. 代码（参考文章：最少硬币找零问题-动态规划）

#include<iostream>
using namespace std;
//money需要找零的钱
//coin可用的硬币
//n硬币种类
void FindMin(int money, int *coin, int n)
{
	int *coinNum = new int[money + 1]();//存储从1块钱开始，到money每个值找零最少需要的硬币的个数
	int *coinValue = new int[money + 1]();//最后加入的硬币，方便后面输出是哪几个硬币
	coinNum[0] = 0;

	for (int i = 1; i <= money; i++)
	{
		int minNum = i;//i面值钱，需要最少硬币个数
		int usedMoney = 0;//这次找零，在原来的基础上需要的硬币
		for (int j = 0; j<n; j++)
		{
			if (i >= coin[j])//找零的钱大于这个硬币的面值，才需要进入下一步判断
			{
				//if(coinNum[i-coin[j]]+1<=minNum)//所需硬币个数减少了
				/*
				上面的判断语句有问题，在更新时，需要判断i-coin[j]是否能找的开，如果找不开，就不需要更新。
				多谢zywscq 指正
				*/
				if (coinNum[i - coin[j]] + 1 <= minNum && (i == coin[j] || coinValue[i - coin[j]] != 0))//所需硬币个数减少了
				{
					minNum = coinNum[i - coin[j]] + 1;//更新
					usedMoney = coin[j];//更新
				}
			}
		}
		coinNum[i] = minNum;
		coinValue[i] = usedMoney;
	}

	//输出结果
	if (coinValue[money] == 0)
		cout << "找不开零钱" << endl;
	else
	{
		cout << "需要最少硬币个数为：" << coinNum[money] << endl;
		cout << "硬币分别为:";
		while (money>0)
		{
			cout << coinValue[money] << ",";
			money -= coinValue[money];
		}
	}
	delete[]coinNum;
	delete[]coinValue;
}
int main()
{
	int Money = 54;
	int coin[] = { 1,2,5,9,10 };
	FindMin(Money, coin, 5);
	getchar();
	return 0;
}

参考文章：

教你彻底学会动态规划——入门篇

《面试--动态规划》 ---五种经典的算法问题

常见的动态规划问题分析与求解

常见动态规划问题总结

SJLin96

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
动态规划问题

一. 从一个例子入门题目：在下面的数字三角形中寻找一条从顶部到底边的路径，使得路径上所经过的数字之和最大。路径上的每一步都只能往左下或右下走。只需要求出这个最大和即可，不必给出具体路径。三角形的行数大于1小于等于100，数字为 0~99。（此题目来源于北大POJ）输入格式： 5 //表示三角形的行数接下来输入三角形 7 3 8...
复制链接

扫一扫

专栏目录