斐波那契数列

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

数列：

f(n)=1(n=1)

2(n=2)

f(n-1)+f(n-2)

public class Solution {
    public int JumpFloor(int target) {
     if(target==1||target==2){
         return target;
     }else
         return JumpFloor(target-1)+JumpFloor(target-2);
    }
}

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

f(n)=1(n=0)

1(n=1)

f(n-1) *2

public class Solution {
    public int JumpFloorII(int target) {
     if(target==1){
         return 1;
     }else
         return 2*JumpFloorII(target-1);
    }
}

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

依旧是斐波那契数列

2*n的大矩形，和n个2*1的小矩形

其中target*2为大矩阵的大小

有以下几种情形：

1⃣️target <= 0 大矩形为<= 2*0,直接return 1；

2⃣️target = 1大矩形为2*1，只有一种摆放方法，return1；

3⃣️target = 2 大矩形为2*2，有两种摆放方法，return2；

4⃣️target = n 分为两步考虑：

        第一次摆放一块 2*1 的小矩阵，则摆放方法总共为f(target - 1)

第一次摆放一块1*2的小矩阵，则摆放方法总共为f(target-2)

public class Solution {
    public int RectCover(int target) {
	if(target<1){
         return 0;
     }
     else if(target==1){
         return 1;
     }
     else if(target==2){
         return 2;
     }
     else 
          return RectCover(target-1)+RectCover(target-2); 
   }
}

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。

n<=39

这个题可以说是迭代（Iteration） VS 递归（Recursion），

f(n) = f(n-1) + f(n-2)，第一眼看就是递归啊，简直完美的递归环境，递归肯定很爽，这样想着关键代码两三行就搞定了，注意这题的n是从0开始的：

1 2	if (n<= 1 )  return n; else return Fibonacci(n- 1 )+Fibonacci(n- 2 );

然而并没有什么用，测试用例里肯定准备着一个超大的n来让Stack Overflow，为什么会溢出？因为重复计算，而且重复的情况还很严重，举个小点的例子，n=4，看看程序怎么跑的：

Fibonacci(4) = Fibonacci(3) + Fibonacci(2);

                    = Fibonacci(2) + Fibonacci(1) + Fibonacci(1) + Fibonacci(0);

                    = Fibonacci(1) + Fibonacci(0) + Fibonacci(1) + Fibonacci(1) + Fibonacci(0);

由于我们的代码并没有记录Fibonacci(1)和Fibonacci(0)的结果，对于程序来说它每次递归都是未知的，因此光是n=4时f(1)就重复计算了3次之多。

那么如何求解呢，动态规划似乎不错，关于动态规划三个条件：最优子结构、无后效性、子问题重叠这些就不谈了，因为理(wo)论(ye)性(bu)太(tai)强(dong)了。

下例是一个简单的动态规划，以一定的空间代价避免代价更大的重复计算的栈空间浪费：

1 2 3 4 5 6 7 8 9 10

if (n<= 1 ){      return n; } int [] record =  new int [n+ 1 ]; record[ 0 ] =  0 ; record[ 1 ] =  1 ; for ( int i= 2 ;i<=n;i++){      record[i] = record[i- 1 ] + record[i- 2 ]; } return record[n];

虽然看起来很蠢，空间浪费了sizeof(int)*(n-1)，但是对于那个超大n的测试用例应该是可以通过了，时间复杂度也达到了O(n)。