day38｜动态规划01｜● 理论基础 ● 509. 斐波那契数 ● 70. 爬楼梯 ● 746. 使用最小花费爬楼梯

509. 斐波那契数

class Solution {
    public int fib(int n) {
        if (n <= 0) return 0;
        // 1. 确定dp[i]数组以及下标的含义
        int[] fib = new int[n+1]; // 3. dp数组初始化
        fib[0] = 0;
        fib[1] = 1;
        for (int i = 2; i <= n; i++) { // 4. 确定遍历顺序
            fib[i] = fib[i-1] + fib[i-2]; // 2. 确定递推公式
        }
        return fib[n];
    }
}

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

70. 爬楼梯

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

注意这里是从dp[1]开始初始化而不是0，因为只有这样才好理解，0初始化却没有意义，不好解释
总是忘记特殊处理n==1的情况，导致初始化step[2] = 2的时候会出界

746. 使用最小花费爬楼梯

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

        dp[0] = 0;
        dp[1] = 0;

        for (int i = 2; i < dp.length; i++) {
            dp[i] = Math.min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2]);
        }
        return dp[dp.length-1];
    }
}

一开始写的很繁复，因为把minCost[0] minCost[1] minCost[2] [3]都拿出来单独思考了，但实际3和4也归属于递推公式，因为可以初始化mincost为0。
注意要从一开始就分清楚递推公式的逻辑。要知道dp[i]是依赖于前两个数组元素的，从2就开始了（即从0爬两级，1爬一级）
还要注意真正的答案是要比cost数组长一步的，因为需要爬最后一级。

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int[] minCost = new int[cost.length+1];
        minCost[0]=cost[0];
        minCost[1]=cost[1];
        if (cost.length == 2) return Math.min(cost[0], cost[1]);
        minCost[2] = Math.min(cost[0], cost[1]);
        if (cost.length == 3) return Math.min(cost[1], minCost[2]+cost[2]);
        minCost[3] = Math.min(cost[1], minCost[2]+cost[2]);
        for (int i = 4; i < minCost.length; i++) {
            minCost[i] = Math.min(minCost[i-1]+cost[i-1], minCost[i-2]+cost[i-2]);
        }
        return minCost[minCost.length-1];
    }
}