汉诺塔递归的空间复杂度_暴力递归与动态规划 1.0

有些暴力递归不能被改成动态规划，因为他本身要求的解空间无法被压缩了。

eg：汉诺塔问题，我们必须打印那些步骤。

如果要写一个动态规划，先写成暴力递归的版本，然后模板化修改。

先写递归版本：

不妨记递归函数是f（）

1.base case 是啥？

如果这个点在右下角，直接返回这个点的数值就可以了。 a[i][j]

如果这个点在最后一行。 返回当前位置的数字+下一步需要的

即： a[i][j] + f[i][j+1]

如果在最后一列

同理 a[i][j] +f[i+1][j]

一般情况：就当前加 右或下的最小值。

#include <iostream>
#include <algorithm>
using namespace std;
const int N=10010;


int walk(int a[N][N],int rows,int columns,int i,int j){
	
	if(i==rows-1 && j==columns-1){
		return a[i][j];
	}
	if(i==rows-1)	return a[i][j]+walk(a,rows,columns,i,j+1);
	if(i==columns-1)	return a[i][j]+walk(a,rows,columns,i+1,j);
	
	return a[i][j]+min(walk(a,rows,columns,i,j+1),walk(a,rows,columns,i+1,j));
}

如果改成非递归的动态规划呢？

首先要思考，什么样的递归可以被改成动态规划？

设这个递归函数是f（0,0） 表示从0 0 位置走到右下角

f(0,0) 会调用 f(0 1) and f(1 0)

f(0 1) 会调用 f(1 1) and f(0 2)

f(1 0) 会调用 f(1 1) and f(2 0)

f（1 1）算过两次，我们可以省去这个步骤

记录f 1 1 状态，下次用上直接拿出来用，就可以节省时间了。

to sum up，当一个递归有重复状态。 并且这个状态与到达他的路径无关。

不管怎么走到达这个位置，对应的状态函数返回值都是一样的，就可以被记录下来，下次再用。

这样的过程，我们称作：

无后效性问题。

状态的参数定了，返回值就定了。

之前的选择无法影响当前的状态。

那么参数的不同就可以 确定不同的返回值。

对应这个问题，参数是 i j 返回值根据i j的不同，值也不同。

f函数也是一张二维矩阵。

我们需要的就是f 0 0 位置的返回值。

回到递归函数中，找到对应的base case 然后填在新的表里。

可以发现： 递归是顺着来，动态规划是反着回去的。