剑指offer-7.裴波那锲数列、8.跳台阶、9.变态跳台阶、10.矩形覆盖（Java）

裴波那锲数列

题目描述

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。
n<=39

解答思路

第一反应，这是一道经典的递归题

public class Solution {
    public int Fibonacci(int n) {
        if(n>39){
            return 0;
        }
        if(n==0||n==1)
            return n;
        else
            return Fibonacci(n-1)+Fibonacci(n-2);
            

    }
}

时间复杂度：O(2^n)
空间复杂度：递归栈中的空间
缺点：慢，运行后1322ms

优化一

动态规划法，优化递归

public class Solution {
    public int Fibonacci(int n) {
        int[] m = new int[40];
        m[0] = 0;
        m[1] = 1;
        for(int i=2;i<=n;i++){
            m[i] = m[i-1]+m[i-2];
        } 
        
        return m[n];
    }
}

时间复杂度：O(n)
空间复杂度：O(n)

优化二

每次使用最相近的两个数，因此仅存储f(n-1)和f(n-2)的值
当前值f(n)：sum
f(n-1)：pre1
f(n-2)：pre2

如：f(2) = f(1) + f(0)
f(3) = f(2) + f(1)
即：
sum = pre1+pre2
pre2 = pre1；
pre1 = sum；

public class Solution {
    public int Fibonacci(int n) {
        if(n==0||n==1)
            return n;
        
        int sum = 0;
        int pre1 = 1;
        int pre2 = 0;
        
        for(int i=2;i<=n;i++){            
            sum = pre1+pre2;
            pre2 = pre1;
            pre1 = sum;
        }
        
        return sum;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

优化三

当前sum = 上一次 sum + 上一次pre1
当前pre1 = 当前 sum - 上一次pre1
如：
上一次：sum = f(2)，prer1 = f(1)
当前：sum（ f(3)）= 上一次 sum（f(2)） + 上一次pre1（f(1)）
pre1（ f(2)） = 当前 sum（f(3)） - 上一次pre1（f(1)）

如：
则

处代码改为
sum = sum + pre1
pre1 = sum - pre1

public class Solution {
    public int Fibonacci(int n) {
        if(n==0||n==1)
            return n;
        
        int sum = 1;
        int pre1 = 0;
        
        for(int i=2;i<=n;i++){            
            sum = sum + pre1;            
            pre1 = sum - pre1;
        }
        
        return sum;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

类似题还有8.跳台阶

变形一：跳台阶

题目描述

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

解答思路

台阶数为1：1种
台阶数为2：2种，1-跳一次，跳2阶；2-跳2次，每次1阶
台阶数为3：（台阶数为1跳法个数+跳2阶） + （台阶数为2跳法个数+跳1阶）
因此，也为类似裴波那锲数列
其中：
f(1) = 1;
f(2) =2
f(n) = f(n-1) + f(n-2)

public class Solution {
    public int JumpFloor(int target) {
        int sum = 0,pre1 = 2,pre2=1;
        
        if(target == 1 || target == 2)
            return target;
        
        for(int i = 3; i<=target;i++){
            sum = pre1+ pre2;
            pre2= pre1;
            pre1 = sum;
        }
        
        return sum;
       
    }
}

变形二：变态跳台阶

题目描述

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

解题思路

通过题目可以分析出
台阶数为1：1种，F(1)
台阶数为2：2种，F(2)
台阶数为3：F(1) + F(2) +1 = 4种
即F(1)跳2步，F(2)跳1步，直接跳3步
台阶数为4：F(1) + F(2) +F(3) + 1 = 8种
即F(1)跳3步，F(2)跳2步，F(3)跳1步，直接跳4步
根据上述描述，可推出公式

F(n) = F(n-1) + F(n-2) +……+F(1) +1
F(n-1) = F(n-2) + F(n-3) +……+F(1) +1

相减得：F(n) =2* F(n-1)

第一种 递归

缺点：慢，时间复杂度高

第二种 动态规划，将结果存在数组中

public class Solution {
    public int JumpFloorII(int target) {
        
        int[] count = new int[target+1];       
        
        if(target == 1 ||target ==2)
            return target;
        
        count[0] = 0;
        count[1] = 1;
        count[2] = 2;
        for(int i=3;i<=target;i++){
            count[i] = 2 * count[i-1];           
        }
        return count[target];
    }
}

时间复杂度：O(n)
空间复杂度：O(n)

变形三：矩形覆盖

题目描述

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。

请问用n个2*1的小矩形无重叠地覆盖一个

2*n的大矩形，总共有多少种方法？

比如n=3时，2*3的矩形块有3种覆盖方法：

n=1时，1种
n=2时，2种，横2 或 竖2
n=3时，4种
即，F(2)时，加一条竖
F(1)时，加两横
以此类推，F(n) = F(n-1) +F(n-2)

public class Solution {
    public int RectCover(int target) {
        if(target == 1 ||target==2)
            return target;
        
        int pre2 = 1;
        int pre1 = 2;
        int sum = 0;
        
        for (int i = 3;i<=target;i++){
            sum = pre1 + pre2;
            pre2 = pre1;
            pre1 = sum;
        }
        
        return sum;

    }
}

时间复杂度：O(n)
空间复杂度：O(1)