算法刷题｜509.斐波那契数、70.爬楼梯、746.使用最小花费爬楼梯

斐波那契数

题目：斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给定 n ，请计算 F(n) 。

递归

class Solution {
    public int fib(int n) {
        if(n == 0){
            return 0;
        }
        if(n == 1){
            return 1;
        }
        return fib(n-1)+fib(n-2);
    }
}

动态规划

1. dp[i]的含义：表示第i个数的斐波那契值
2. 递推公式：dp[i]=dp[i-1]+dp[i-2]
3. dp数组初始化：dp[0]=0,dp[1]=1
4. 遍历顺序：从前向后
5. 打印dp数组：debug用

class Solution {
    public int fib(int n) {
        if(n <= 1){
            return n;
        }
        int[] dp = new int[n+1];
        dp[0] = 0;
        dp[1] = 1;
        for(int i = 2;i<=n;i++){
            dp[i] = dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
}

优化
可以看出上面dp[i]的值只和前两个数有关和之前的数没有关系，所有我们可以不用n+1大小的数组了

class Solution {
    public int fib(int n) {
        if(n <= 1){
            return n;
        }
        int[] dp = new int[2];
        dp[0] = 0;
        dp[1] = 1;
        int sum = dp[0]+dp[1];
        for(int i = 2;i<=n;i++){
            dp[0] = dp[1];
            dp[1] = sum;
            sum = dp[0]+dp[1]; 
        }
        return dp[1];
    }
}

爬楼梯

题目：假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

1. dp[i]的含义：第i阶台阶有dp[i]种方法到达
2. 递推公式：dp[i] = dp[i-1]+dp[i-2]
3. dp数组初始化：dp[1]=1,dp[2]=2
4. 遍历顺序：从前向后
5. 打印dp数组：debug用

class Solution {
    public int climbStairs(int n) {
        if(n == 1){
            return 1;
        }
        int[] dp = new int[n+1];
        dp[1] = 1;
        dp[2] = 2;
        for(int i = 3;i<=n;i++){
            dp[i] = dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
}

优化
本题和斐波那契数列基本一样，所有本题也可以使用三个变量来实现

class Solution {
    public int climbStairs(int n) {
        if(n == 1){
            return 1;
        }
        int p = 1,q =2,r = 3;
        for(int i = 3;i<=n;i++){
            p = q;
            q = r;
            r = p+q;
        }
        return q;
    }
}

使用最小花费爬楼梯

题目：给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

1. dp[i]的含义：爬到第i阶需要花费dp[i]费用
2. 递推公式：dp[i] = Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2])
3. dp数组初始化：dp[0]=0,dp[1] = 0，因为题目给定的是可以从0或者1开始，开始站在0或者1是不需要花费的，所有都赋值0
4. 遍历顺序：从前向后
5. 打印dp数组：debug

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        // 台阶的顶是在下标为cost.length的位置
        int[] dp = new int[cost.length+1];
        dp[0] = 0;
        dp[1] = 0;
        for(int i = 2;i<=cost.length;i++){
            // 可以从0开始也可以从1开始，选择花费小的
            dp[i] = Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        }
        return dp[cost.length];
    }
}