递归问题的延展（斐波那契数列专场）

1、跳台阶

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

solution    1：

递归解决，自顶而下

确定一次只能跳上1阶或2阶，类似于斐波那契数列的问题，要求n阶的跳法，只需确定了前两项的阶梯数后，依次往下递归求跳法

public int JumpFloor(int target) {

        if(target==0)

            return 0;

        else if(target==1)

            return 1;

        else if(target==2)

            return 2;

        else

            return JumpFloor(target-1)+JumpFloor(target-2);

    }

solution    2：

迭代解决，动态规划，自底而上

运用动态规划，从第3项开始，自前而后求前两项的跳法总数，最后算出n阶的跳法。

public int JumpFloor(int target) {

        if(target==0||target==1||target==2)

            return target;

        int jumpSum=0;

        int jumpBackPre=1;

        int jumpBackPrePre=2;

        for(int i=3;i<=target;i++){

            jumpSum=jumpBackPre+jumpBackPrePre;

            jumpBackPre=jumpBackPrePre;

            jumpBackPrePre=jumpSum;

        }

        return jumpSum;

    }

2、变态跳台阶

题目描述

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

solution    1：

（纯数学问题，通过1，2，3阶台阶类比数列找规律）

关于本题，前提是n个台阶会有一次n阶的跳法。分析如下:

f(1) = 1

f(2) = f(2-1) + f(2-2)         //f(2-2) 表示2阶一次跳2阶的次数。

f(3) = f(3-1) + f(3-2) + f(3-3) 

...

f(n) = f(n-1) + f(n-2) + f(n-3) + ... + f(n-(n-1)) + f(n-n) 

 

说明： 

1）这里的f(n) 代表的是n个台阶有一次1,2,...n阶的 跳法数。

2）n = 1时，只有1种跳法，f(1) = 1

3) n = 2时，会有两个跳得方式，一次1阶或者2阶，这回归到了问题（1） ，f(2) = f(2-1) + f(2-2) 

4) n = 3时，会有三种跳得方式，1阶、2阶、3阶，

    那么就是第一次跳出1阶后面剩下：f(3-1);第一次跳出2阶，剩下f(3-2)；第一次3阶，那么剩下f(3-3)

    因此结论是f(3) = f(3-1)+f(3-2)+f(3-3)

5) n = n时，会有n中跳的方式，1阶、2阶...n阶，得出结论：

    f(n) = f(n-1)+f(n-2)+...+f(n-(n-1)) + f(n-n) => f(0) + f(1) + f(2) + f(3) + ... + f(n-1)

    

6) 由以上已经是一种结论，但是为了简单，我们可以继续简化：

    f(n-1) = f(0) + f(1)+f(2)+f(3) + ... + f((n-1)-1) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2)

    f(n) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2) + f(n-1) = f(n-1) + f(n-1)

    可以得出：

    f(n) = 2*f(n-1)

    

7) 得出最终结论,在n阶台阶，一次有1、2、...n阶的跳的方式时，总得跳法为：

              | 1       ,(n=0 ) 

f(n) =     | 1       ,(n=1 )

              | 2*f(n-1),(n>=2)

具体实现（java）：

public int JumpFloorII(int target) {

        if(target<=0)

            return -1;

        else if(target==1)

            return 1;

        else

            return 2*JumpFloorII(target-1);

    }

3、矩形覆盖

题目描述

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

solution    1:

依旧是斐波那契数列

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)

因为，摆放了一块1*2的小矩阵（用√√表示），对应下方的1*2（用××表示）摆放方法就确定了，所以为f(targte-2)

 

 

 

具体实现：

public int RectCover(int target) {

        if(target<=1)

            return target;

        if(target*2==2)

            return 1;

        if(target*2==4)

            return 2;

        else

            return RectCover(target-1)+RectCover(target-2);

    }

总结：

类似的斐波那契问题，都可以用数列的数学思想来推算，一个方法是递归，另一个方法是迭代（动态规划），递归/迭代都是求出前两项的确定结果，而后往后第n项就是求前两项的总和，或应用数学规律直接解决问题。

一般来说，迭代的时间复杂度都小于递归。