浅析动态规划-----------不看后悔系列

写在前面的话

讲道理，我对dp这块的理解并不深，当初学的时候，也仅仅停留在一些名词上。比如大佬们经常说的数位dp，树形dp，区间dp，插头dp，棋盘dp，背包dp等等。。。

那究竟什么是dp呢?维基百科上是这样定义的：

DP就是一种方法，该方法能够将复杂的问题分解成为一系列简单的子问题。

时隔一段时间了，准备好好把dp这个算法总结总结，不会的地方抓紧补上，会的地方夯实夯实，写出一些自己不一样的见解，争取在每天的积累中，能够不断的进步。

在介绍DP之前，我们还是先来看看什么是递推，什么是递归？因为，我觉得，要想把dp的问题做好，必须对于递推和递归的理解够深入，这样才能在后续理解dp的过程中，游刃有余。

从一道题目讲起

先从上楼梯问题1来说：

每次只能上1个台阶，或者两个台阶。求上到第n节台阶的总的方法数是多少？
这个问题，先从最原始的想法开始。

如果我们正着开始想。
当n=1时，只有1种方法
当n=2时，有2种方法
当n=3时，有3种方法
当n=4时，有5种方法
。。。
当n=k时候，聪明的读者可能会总结出规律来，答案为f(k-1)+f(k-2)

但是，如果你对于这些数字不敏感的话，有可能不能得出这个结论。这个时候，我们不妨把问题的角度转换下。比如说，我们从最后一节台阶来开始，倒着考虑问题。假如说我们站在最后一节台阶，那么怎么样才能达到最后一节台阶呢？

● 从倒数第二层，一次性上两节台阶到达最后一层
● 从倒数第一层，一次性上一节台阶到达最后一层

令最后一层台阶是n，这样，到达最后一节的方法数就是f(n) = f(n-1)+f(n-2)了。
然后，我们倒着推问题，最后就得到了一个边界条件,f(1)=1, f(2) = 2
那么无论n（n>=1）取多少，我们都可以得到最终的解。
关于f(n-1)和f(n-2)我们把它定义为最优子结构
f(1)=1, f(2) = 2定义为边界
f(n) = f(n-1)+f(n-2)定义为状态转移方程

这三个概念是所有dp问题中所包含的最重要的概念。我们必须要好好吃透它，关于这三个概念的定义和使用，下面的问题还会多次出现，如果不是很懂，不要紧，耐住性子，继续往下读就行了。

到这里，我们就能够写出来这个问题的递归求解过程

int fun( int step ) {
	if ( step < 1  ) return 0; 
	if ( step == 1 ) return 1;
	if ( step == 2 ) return 2;
	else return fun(step-1)+fun(step-2);
}

是不是感觉我们已经把这个题目完美的解决了呢？我们再来分析下这个问题的时间复杂度和空间复杂度各是多少。

可以看出，时间复杂度是O(2^n),空间复杂度也是O(n)。

时间复杂度太高了，发现问题了吗?其实，在我们每次递归的过程中，都会有重复计算的部分。比如说，f(8) = f(7)+f(6) ， f(7) = f(6)+f(5),但是当我们计算f(7)的时候，需要f(6)。

计算f(8)的时候也需要计算f(6)。这两个是同一个f(6)。故，只需计算一次就行了。

那么，我们就针对这个问题引入一个新的东西，叫做记忆化数组。

记忆化数组的作用就是干这样的事情的，使得那些需要重复计算过的部分仅仅计算一次，尽快的求出问题的解。类似hash的思想，来暂存计算结果。

实现代码如下：

int memory[MAX]={0};
int fun( int step ) {
	if ( memory[step]!=0 ) return memory[step];
	if ( step<1 ) return 0;
	if ( step==1 ) return 1;
	if ( step==2 ) return 2;
	else return memory[step] = fun(step-1)+fun(step-2);
}

再来分析下时间复杂度和空间复杂度各为多少？

首先，时间复杂度就是O(n)，空间复杂度也为O(n)

其实，做到这一步实际上就可以了，时间上已经是最快的了，你要是还想把空间复杂度再变低一些，那就是优化到O（1）。这个可以借助我们先前学过的斐波那契数列的循环式写法来做。

int fun( int step ) {
	if ( step < 1 ) return 0;
	if ( step == 1 ) return 1;
	if ( step == 2 ) return 2;
	int a = 1;
	int b = 2;
	int temp = 0;
	for ( int i = 3;i <= step;i++ ) {
		temp = a+b;
		a = b;
		b = temp;
	}
	return temp;
}

这个爬楼梯问题，我们已经解决的非常好了，那么接下来，我们再来将问题进一步的加强。

---

上楼梯问题2：

● 每次爬楼梯时，可以往上爬不超过4节( 1,2,3,4 )
● 求爬上N节楼梯的不同方案数

还是和刚刚的问题求解思路一样，我们从最后一步开始看问题。

f(n) = f(n-1)+f(n-2)+f(n-3)+f(n-4)
当n=4时，f(4) = f(3)+f(2)+f(1)+f(0)

那么，通过手算，我们得到f(1) = 1, f(2) = 2, f(3) = 4, f(4) = 8
这样来看f(0) = 8-4-2-1 = 1

所以，我们就得到了上楼梯问题2的最优子结构，边界，状态转移方程，该问题就顺利解决了。代码如下

int fun( int step ) {
	if ( step==0 ) return 1;
	if ( step==1 ) return 1;
	if ( step==2 ) return 2;
	if ( step==3 ) return 4;
	return f(step-1)+f(step-2)+f(step-3)+f(step-4);
}

---

上楼梯问题3：

当我们把每次可以往上爬的台阶数规定为不超过n的时候。

那么，求上到第n节台阶所需要的方法数。

如果还是用前面的最优那个O(n)的方法， 当n趋向特别大的时候，该方法显然不成立。
那么，我们就可以通过使用矩阵乘法+快速幂的方法把问题降低到O(logn)的复杂度。

通过矩阵快速幂，就能达到O(logn)的复杂度

---

递归：

什么是递归呢？我对于递归的理解就是一个自己调用自己的过程，但是往往递归的过程中，必须要明确递归终止的条件是什么，如果你不知道递归终止的条件，那么就会导致栈溢出的问题。

和很多讲算法的书一样，讲解递归的时候，一开始给大家介绍的也是“汉诺塔”问题。

汉诺塔问题其实可以被拆分成三个步骤子问题来思考：

第一个步骤子问题：首先将A柱子上的前n-1个盘子，借助C柱子，移动到B柱子上
第二个步骤子问题：然后将A柱子上的第n个盘子，直接移动到C柱子上
第三个步骤子问题：将B柱子上的前n-1个盘子，借助A柱子，移动到C柱子上。

如果按照次序执行上述步骤子问题，我们就能得到最终问题的解。细心的读者可能会发现，第一个步骤子问题和第三个步骤子问题的本质是一样的，只不过方法所应对的参数有所不同。那这个时候递归就可以起到作用了。解决的代码如下所示：