算法介绍
动态规划(Dynamic Programming)的核心是当前状态的解由上一状态得到。算法将求解问题分解成多个相似的子问题,每个子问题的解由上一个子问题的解得到并储存,往往用于优化递归问题,减少相同子问题的重复计算。
一维动态规划·爬楼梯问题
问题描述
假设你正在爬楼梯,需要 n 阶你才能到达楼顶,每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢?
示例 1:
输入:n = 2
输出:2
解释:有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶
示例 2:
输入:n = 3
输出:3
解释:有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶
算法分析
爬n阶楼梯的上一个状态是已经爬了n-1阶楼梯,再爬1阶到了n阶,或者是已经爬了n-2阶楼梯,再爬2阶到了n阶。所以爬到n阶楼梯所有方法数等于爬n-1阶楼梯的解+爬n-2阶楼梯的解。而爬n-1阶楼梯的解又等于n-2阶的解+n-3阶的解......可以看到这是一个递归问题,但用传统递归方法去算,n-2阶的解便会被重复计算,当处理数据过大时,算法效率明显降低。
因此我们使用动态规划的思维创建一个动态规划数组dp来保存每个状态的解,并由该解推出下一个状态的解,这样每个解只需要计算一次,时间效率明显提升。
我们观察到该题只有一个变量n,因此只需要创建一个一维数组dp[],dp[n] = dp[n-1] + dp[n-2]。
代码实现(C语言)
//动态规划
#include "stdio.h"
#include "stdlib.h"
int main()
{
int n,i,*dp;
scanf("%d",&n);
dp=(int *)malloc(sizeof(int)*n);//动态内存数组,也可以根据题设n最大值用静态数组
dp[1]=1,dp[2]=2;
for(i=3;i<=n;i++)
dp[i]=dp[i-1]+dp[i-2];
printf("%d",dp[n]);
return 0;
}
我们注意到递推过程中实际上只有最新创建的3个数组空间被利用,而此前计算的数据只使用了一次就没用了,我们可以用滚动数组3个变量来优化。
//滚动数组
#include "stdio.h"
int main()
{
int n;
scanf("%d",&n);
int a=1,b=2,c=n;
while(n-->=3)
{
c=a+b;
a=b;
b=c;
}
printf("%d",c);
return 0;
}
二维动态规划·印章问题
问题描述
共有n种图案的印章,每种图案的出现概率相同。小A买了m张印章,求小A集齐n种印章的概率。
输入格式
一行两个正整数n和m
输出格式
一个实数P表示答案,保留4位小数。
样例输入
2 3
样例输出
0.7500
数据规模和约定
1≤n,m≤20
算法分析
买m张印章集齐n种不同印章的上一状态是买m-1张集齐了n-1种,第m张为不同的,或者买m-1张时就已经集齐了n种,第m张为重复的。即买了m张有n张不同印章的概率为买m-1张时有n-1张不同印章,第m张为不同的的概率+买m-1张时有n张不同印章,第m张为n张中的一张的概率。而这两种情况又可以继续往下分。
这是一个递归问题,如果使用纯数学计算概率的思路用传统递归也能解:
//传统递归
#include "stdio.h"
#include "math.h"
double f(double x,double y);//x为已经买到了x种不同的印章,y为买到的第y个印章
double n,m;
int main()
{
scanf("%lf %lf",&n,&m);
printf("%.4lf",f(0,1));
return 0;
}
double f(double x,double y)
{
if(y>m && x<n)
return 0;
if(x<n)
return (n-x)/n*f(x+1,y+1)+x/n*f(x,y+1);
/*数学概率统计
在m次购买得到n种印章的成功情况下,
第y次买到新印章和第y次买到重复印章的概率*/
else
return 1;
}
但深度递归在处理较大数据时时间效率很低很低,在n=10,m=30时就开始不行了,而动态规划算法在m=300时依然秒出结果。
因此我们看动态规划的思路,把每一种状态记录,然后用这一状态的数据计算出下一状态的解。
假设n为4,m为6,总共4种不同印章。
创建二维动态规划数组dp[][],
记子状态为dp[i][j],买了i张,有j种不同印章的概率(i=0和j=0的空间就不用了)。列表(打表)如下:
每种状态的概率 | j | ||||
---|---|---|---|---|---|
1 | 2 | 3 | 4 | ||
i | 1 | 1 | 0 | 0 | 0 |
2 | 0 | 0 | |||
3 | 0 | ||||
4 | |||||
5 | |||||
6 |
容易知道,只买1张,不可能有两张不同印章,即当 j>i 时概率为0;只买一张,这一张一定是新的,概率为1;买两张,却只获得一张新的(总共有4种不同印章),两张是重复的概率为
即 ,可以看出 i=1 也满足公式,所以当 j=1 时,该子状态出现的概率为
,即
。
当 i>j 时,dp[i][j]=dp[i-1][j-1]*第i张买到新印章的概率 + dp[i-1][j]*第i张买到重复印章的概率,即
代码实现(C语言)
//动态规划
#include "stdio.h"
#include "math.h"
int main()
{
int n,m,i,j;
scanf("%d %d",&n,&m);
/*也可以用动态内存二维数组,引入头文件"stdlib.h"
double p=1.0/n,**dp=(double **)malloc(sizeof(double*)*(m+1));
for(i=1;i<=m+1;i++)
dp[i]=(double *)malloc(sizeof(double)*(n+1));
*/
double p=1.0/n,dp[21][21];
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
if(i<j)
dp[i][j]=0;
else if(j==1)
dp[i][j]=pow(p,i-1);
else
dp[i][j]=dp[i-1][j]*p*j+dp[i-1][j-1]*p*(n-(j-1));
printf("%.4lf",dp[m][n]);
return 0;
}
附
列表时也可以用买了j张作列,获得i种不同印章作行,代码条件条件判断稍微变换即可:
还是n=4,m=6,
每种状态的概率 | j | ||||||
---|---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | 6 | ||
i | 1 | 1 | |||||
2 | 0 | ||||||
3 | 0 | 0 | |||||
4 | 0 | 0 | 0 |
//动态规划
#include "stdio.h"
#include "math.h"
int main()
{
int m,n,i,j;
scanf("%d%d",&n,&m);
double p=1.0/n,dp[21][21];
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
if(i>j)
dp[i][j]=0;
else if(i==1)
dp[i][j]=pow(p,j-1);
else
dp[i][j]=dp[i][j-1]*p*i+dp[i-1][j-1]*p*(n-(i-1));
printf("%.4lf",dp[n][m]);
return 0;
}