代码随想录训练营day38|dp：509斐波那契数、70.爬楼梯、746.最小花费爬楼梯

LeetCode

这一题是可以优化空间的。但是就不太易于理解dp了。

class Solution {
    public int fib(int n) {
        /* 第三遍
        dp[i]: n=i时 的斐波那契额数值
        dp[i] = dp[i-1]+dp[i-2]
        初始化：dp[0]=0,dp[1]=1
        循环方向：从前到后
        */
        if(n < 2){
            return n;
        }
        int[] dp = new int[n+1];
        dp[0] = 0;
        dp[1] = 1;
        for(int i=2;i<dp.length;i++){
            dp[i] = dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
}

优化空间

class Solution {
    public int fib(int n) {
        /** 第二遍

        dp[i]:斐波那契额数列
        dp[i] = dp[i-1]+ dp[i-2]
        初始化：dp[0] = 0, dp[1] = 1
        循环方向：前->后
        可以进一步优化空间的int[] dp = new int[2]
        */
        if(n<2){
            return n;
        }
        int[] dp = new int[n+1];
        dp[1] = 1;
        for(int i=2;i<=n;i++){
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }
}

LeetCode70爬楼梯

class Solution {
    public int climbStairs(int n) {
        /* 第三遍
        这一题，可以按照最基本的解法，也可以按照完全背包问题来写。
        dp[i] : 到达第i个台阶有多少种方法
        dp[i] = dp[i-1] + dp[i-2]
        初始化：dp[1] = 1  dp[2] = 2  其他为0
        循环方向：前-后
        */
        if(n <= 2){
            return n;
        }
        int[] dp = new int[n];
        dp[0] = 1;
        dp[1] = 2;
        for(int i=2;i<n;i++){
            dp[i] = dp[i-1]+dp[i-2];
        }
        return dp[n-1];
    }      
}

LeetCode746使用最小花费爬楼梯

class Solution {
    public int minCostClimbingStairs(int[] cost) {
       /** 第三遍：多了一个比较的过程
        dp[i]: 到达第i个台阶所需要支付的成本。可理解为从1开始数的台阶。
        这种方式是离开之后在计算成本，所以开始的位置 初始化都为0
        例如dp[3] 表示到达第三个台阶所需要的成本 
        [10, 15 , 20]
        [0, 0, 10, 15]
        [0, 1, 2,  3] 
        dp[3]就是结果。
        dp[i] = Math.min(dp[i-2] +cost[i-2], dp[i-1]+cost[i-1]
        初始化：这里dp[i]这样定义就是考虑了在第一步开始走的时候不用支付成本。因此dp[0] =0;dp[1]=0    其他的dp[i] = 0;
        循环：从前往后
        */
        int size = cost.length;
        int[] dp  =new int[size+1]; // 多一位 开始的时候不支付费用
        dp[0] = 0;
        dp[1] = 0;
        for(int i=2;i<=size;i++){
            dp[i] = Math.min(dp[i-2] + cost[i-2], dp[i-1] + cost[i-1]);
        }
        return dp[size];
    }
}

解法二

class Solution {
    public int minCostClimbingStairs(int[] cost) {
       /** 第三遍：多了一个比较的过程
        第一步计算成本，也就是到达这个位置就要成本。另一个是离开这个位置才需要成本
        dp[i]: 到达i位置台阶所需要的成本
        dp[i] = Math.min(dp[i-1], dp[i-2])+cost[i];因为只能前进一步或者两步，因此必须和dp[i-1] dp[i-2] 比较得到最小的，然后加上当前i位置的成本
        dp[0] = cost[0]; dp[1] = cost[1];
        循环方向：前 到 后

        */
        int size = cost.length;
        int[] dp = new int[size];
        dp[0] = cost[0];
        dp[1] = cost[1];
        for(int i=2;i<size;i++){
            dp[i] = Math.min(dp[i-1], dp[i-2]) + cost[i];
        }
        return Math.min(dp[size-1], dp[size-2]); // 最后还需要比较一下，因为这里的dp只是记录了到达cost里台阶位置的成本 还不是到达 台阶的顶部。所以还需要再跳一次。但是这一次就不用再算成本了。
        // 因为这种方式是，落地那一刻就把成本算上了
    }
}