经典递归问题与动态规划

参考链接：https://blog.csdn.net/summer070825/article/details/76572434
http://www.cnblogs.com/DarrenChan/p/8734203.html

一些经典递归问题

斐波那契数列问题

经典生兔子问题，不再赘述。
从该算法改进过程看递归问题的优化求解方式。
version 1:

long Fibonacci(int n){
    
	if(n == 0)
		return 0;
	else if(n == 1)
		return 1;
	else if(n > 1)
		return Fibonacci(n - 1) + Fibonacci(n - 2);
	else return -1;
		
}

最基本的递归问题最基本的写法，但其效率之低令人发指，复杂度为O(2^n);重复了大量的递归调用，很多结果计算了多次。因此为了避免重复计算，可以将计算过的值记录下来。
Version 2:

long tempResult[max]={
    0};
long FIbonacci2(int n){
    
	if(n == 0)
		return 0;
	else if(n == 1)
		return 1;
	else if(n > 1){
    
		if(tempResult[n] != 0)
			return tempResult[n];
		else{
    
			tempResult[n] = Fibonacci2(n - 1) + Fibonacci2(n - 2);
			return tempResult[n];
		}
	}
}

递归就会大量使用栈来存储调用信息和变量，要真正提高效率就得放弃递归。我们可以将从大到小分解问题的递归变为从小问题通往大问题的循环。

public class Fibonacci3 {
    
	public static long Fibonacci3(int n) {
    
		if (n < 0) return -1;

		long[] temp = new long[n+1];
		temp[0] = 0;
		if(n>0) temp[1] = 1;
		for(int i= 2;i <= n; i++) {
    
			temp[i] = temp[i-2] + temp[i-1];
		}
		
		return temp[n];
	}
	public static void main(String[] args) {
    
		// TODO 自动生成的方法存根
		System.out.println(Fibonacci3(0));
	}

}

a,b,c=b,c,a+c
一次循环的O(n);再用分治策略优化还可以得到O(logn)复杂度的方法。

汉诺塔问题

架设3根柱子分别为A、B、C，圆盘数目为n。

1:如果A有一个圆盘，则直接移动至c。

2:如果A有2个圆盘，则A->B,A->C,B->C。

好了这个时候已经可以解决问题了，结束条件为 n==1；

void hano1(char A, char B, char C,int n){
    
	if( n == 1){
    
		print(A+"->"+C);
	}
	else{
    
		hanoi(A, C, B, n-1);
		print(A+"->"+C);
		hanoi(B