day38 | 509斐波那契数,70 爬楼梯，746 使用最小花费爬楼梯

动态规划理论基础

动规基础
背包问题
打家劫舍
股票问题
子序列问题

---

动态规划五部曲：
dp数组以及下标的含义，dp[i]是什么意思，dp[i]中的i是什么意思
递推公式
dp数组如何初始化
遍历顺序
打印dp数组【主要用来debug】

509斐波那契数

确定dp[i]含义，dp[i]：第i个斐波那契数的数值为dp[i]
确定递推公式：dp[i] = dp[i - 1] + dp[i - 2]
dp数组如何初始化：dp[0] = 1, dp[1] = 1
确定遍历顺序：从前向后
打印dp数组

class Solution {
    public int fib(int n) {
        if (n < 2) return n;
        int a = 0, b = 1, c = 0;
        for (int i = 1; i < n; i++) {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
}

70 爬楼梯

dp数组含义：
dp[i] : 达到 i 阶有 dp[i] 种方法
dp[i - 2]: 达到 i - 2 有 dp[i - 2] 种方法
dp[i - 1]: …
递推公式：
dp[ i ] = dp[ i -2 ] + dp[ i - 1]
初始化：
dp[ 0 ] = 1, 表示到第0阶有一种方法，即站在原地
dp[ 0 ] = 0, 表示没有动，原本就在第0阶，没有用方法，所以有0种方法
力扣中，0阶为非法值
正确初始化：dp[1] = 1, dp[2] = 2
遍历顺序：
从前到后，因为需要用到前面数的计算结果

// 常规方式
public int climbStairs(int n) {
    int[] dp = new int[n + 1];
    dp[0] = 1;
    dp[1] = 1;
    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[n];
}

// 用变量记录代替数组
class Solution {
    public int climbStairs(int n) {
        if(n <= 2) return n;
        int a = 1, b = 2, sum = 0;

        for(int i = 3; i <= n; i++){
            sum = a + b;  // f(i - 1) + f(i - 2)
            a = b;        // 记录f(i - 1)，即下一轮的f(i - 2)
            b = sum;      // 记录f(i)，即下一轮的f(i - 1)
        }
        return b;
    }
}

746 使用最小花费爬楼梯

明确dp数组含义
dp[i] ：i 表示到哪个台阶了，dp[i] 表示到达 i 位置的最小消耗
递推公式：
dp[i] 可以是dp[i - 1] 跳了一步走到的，也可以是dp[ i - 2] 跳了两步走到的，那么
dp[i- 1]的花费为cost[ i - 1], dp[ i - 2] 的花费为cost[ i - 2],
从dp[i - 1] 到dp[i]的花费为dp[i - 1] + cost[i - 1] , dp[i - 1]表示走到dp[i-1]的花费，+cost[i - 1]表示走到dp[i]要花费cost[i - 1]
从dp[i - 2] 到dp[i]的花费为dp[i - 2] + cost[i - 2] , dp[i - 2]表示走到dp[i-2]的花费，+cost[i - 2]表示走到dp[i]要花费cost[i - 1]
所以dp[i] = min( dp[i - 1] + cost[i - 1], dp[ i - 2] + cost[i - 2] )

初始化：
dp2 由 dp1和dp0决定
dp3 由 dp2和dp1决定
所以我们初始化dp1和dp0就可以
站在0的位置花费为0，站在1的位置花费为0，只有往上走的时候才会花费
dp[0] = 0
dp[1] = 0
确定遍历顺序：
从前向后
打印数组【debug用】

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int len = cost.length;
        int[] dp = new int[len + 1];

        // 从下标为 0 或下标为 1 的台阶开始，因此支付费用为0
        dp[0] = 0;
        dp[1] = 0;

        // 计算到达每一层台阶的最小费用
        for (int i = 2; i <= len; i++) {
            dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
        }

        return dp[len];
    }
}