动态规划·爬楼梯问题（一维）与印章问题（二维）

算法介绍

动态规划（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;
}