动态规划（一）：爬楼梯问题

动态规划
动态规划是一种用来解决一类问题的算法，用这类算法解决的问题需要具有以下特点：具有 最优子结构、子问题重叠、无后效性

如果子问题不重叠，可以用分治算法
在一定程度上，动态规划和递归两种方法可以相互转换，就是
有些问题用动态规划能解决的也可以用递归解决
举例子：爬楼梯问题
问题描述：有一楼梯共M级，刚开始时你在第一级，若每次只能跨上一级楼梯或者二级楼梯，要走上第M级楼梯，共有多少种走法？

输入：输入一个整数M,（1<=M<=40),表示楼梯的级数。

输出:对于测试实例，请输出不同走法的数量

输入样例:
2
输出样例：
1

输入样例：
3
输出样例：
2

对于这个问题进行分析：
设 现在处于第 i 阶楼梯上，到达 i 阶楼梯共有 dp[i] 种
i = 1 ，处于第一阶楼梯上，则dp[i] = 0(起始位置是1）
i = 2 ，处于第二阶楼梯上，则dp[i] = 1(只有一种走法：从1到2)
i = 3 ，处于第三阶楼梯上，则dp[i] = 2(两种走法：1到3,2到3)
注意：从i = 4开始就出现规律
i = 4 ，处于第四阶楼梯上，则dp[i] = dp[i - 1] + dp[i - 2] = 3
（只能3到4或2到4，所以第四阶走法总数就是dp[2] + dp[3]）

放上递归方法解决的代码：

#include<iostream>
#include<string.h>
#define MAX 45
int a[MAX];
using namespace std;
int g(int n);//递归 
int main()
{
	memset(a,0,sizeof(a));
	int n;
	cin >> n;
	a[1] = 0;
	a[2] = 1;
	a[3] = 2;
		f(n);
		cout << g(n) << endl;//递归 
	return 0;
}

int g(int n)//递归 
{
	if(n == 1)
		return 0;
	else if(n == 2)
		return 1;
	else if(n == 3)
		return 2;
	
	return g(n - 1) + g(n - 2);
	
}

放上动态规划方法解决的代码：

#include<iostream>
#include<string.h>
#define MAX 45
int a[MAX];
using namespace std;
void f(int n);//动态规划 
int main()
{
	memset(a,0,sizeof(a));
	int n;
	cin >> n;
	a[1] = 0;
	a[2] = 1;
	a[3] = 2;
		f(n);
		cout << a[n] << endl;//动态规划 
	return 0;
}

void f(int n)//动态规划 
{
	int i;
	for(i = 4;i <= n;i ++)
	{
		a[i] = a[i - 1] + a[i - 2];
	}
}

如果我们要求f(6),则需要知道f(5)和f(4),而求f(5)要知道f(4)和f(3),求f(4)要知道f(3)和f(2),这就有大量的子问题重复

不难发现，动态规划每求出f(n)都会将其保存进数组中，以便下次直接用，不用再计算一遍f(n)之前的，而递归是 每一阶段都把以前的全部都重新计算一遍，这样递归带来的问题就是时间复杂度会很大，导致提交超时，而动态规划就可以使问题的规模小很多！

所以动态规划对于递归的优势就在于，对于大量重复的子问题，动态规划在第一次求的时候就保存进了数组，不用再求第二次，下次再用直接从数组中拿出来即可，所以动态规划算法也叫查表法。而递归每求一个新的问题就要把这个问题的所有子问题都求一遍。