BM64-最小花费爬楼梯

题目

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

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

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

数据范围：数组长度满足1≤n≤10^5  ，数组中的值满足1≤costi​≤10^4。

示例1

输入：[2,5,20]

返回值：5

说明：你将从下标为1的台阶开始，支付5 ，向上爬两个台阶，到达楼梯顶部。总花费为5。

示例2

输入：[1,100,1,1,1,90,1,1,80,1]

返回值：6

说明：你将从下标为 0 的台阶开始。

1. 支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。
2. 支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。
3. 支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。
4. 支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。
5. 支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。
6. 支付 1 ，向上爬一个台阶，到达楼梯顶部。  

总花费为6。

---

思路：动态规划

动态规划，英文：Dynamic Programming，简称DP。如果某一问题有很多重叠子问题，使用动态规划是最有效的。

动态规划算法的基本思想是：

• 将待求解的问题分解成若干个相互联系的子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
• 对于重复出现的子问题，只在第一次遇到的时候对它进行求解，并把答案保存起来，让以后再次遇到时直接引用答案，不必重新求解。
• 动态规划算法将问题的解决方案视为一系列决策的结果。
• 所以动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，贪心没有状态推导，而是从局部直接选最优的。

动态规划的解题步骤：

1. 确定dp数组（dp table）以及下标的含义。
2. 确定递推公式。
3. dp数组如何初始化。
4. 确定遍历顺序。
5. 举例推导dp数组。

为什么要先确定递推公式，然后在考虑初始化呢？——因为一些情况是递推公式决定了dp数组要如何初始化！

题目中说 “你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯” 也就是相当于直接跳到下标 0 或者直接跳到下标 1 是不花费体力的， 从下标 0 跳到下标1 开始跳就要花费体力了。

• step1：确定dp数组以及下标的含义。

使用动态规划，就要有一个数组来记录状态，本题只需要一个一维数组dp[i]就可以了。

dp[i]的定义：到达第i台阶所花费的最少体力为dp[i]。

• step2：确定递推公式。

可以有两个途径得到dp[i]，一个是dp[i-1] 一个是dp[i-2]。

dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1]。

dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2]。

那么究竟是选从dp[i - 1]跳还是从dp[i - 2]跳呢？

一定是选最小的，所以dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);

• step3：dp数组如何初始化？

看一下递归公式，dp[i]由dp[i - 1], dp[i - 2]推出，既然初始化所有的dp[i]是不可能的，那么只初始化dp[0]和dp[1]就够了，其他的最终都是dp[0]，dp[1]推出。

那么 dp[0] 应该是多少呢？ 根据dp数组的定义，到达第0台阶所花费的最小体力为dp[0]，那dp[0] 应该是 cost[0]，例如 cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1] 的话，dp[0] 就是 cost[0] 应该是1。

但注意题目描述中明确说了 “你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。” 也就是说从到达第 0 个台阶是不花费的，但从第0个台阶往上跳的话，需要花费 cost[0]。

所以初始化 dp[0] = 0，dp[1] = 0。

• step4：确定遍历顺序。

最后一步，递归公式有了，初始化有了，如何遍历呢？本题的遍历顺序其实比较简单。

因为是模拟台阶，而且dp[i]由dp[i-1]，dp[i-2]推出，所以是从前到后遍历cost数组就可以了。

但是稍稍有点难度的动态规划，其遍历顺序并不容易确定下来。

例如：0-1背包，都知道两个for循环，一个for遍历物品嵌套一个for遍历背包容量，那么为什么不是一个for遍历背包容量嵌套一个for遍历物品呢？ 以及在使用一维dp数组的时候遍历背包容量为什么要倒序呢？这些都与遍历顺序息息相关。

• step5：举例推导dp数组。

拿cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1] 来模拟一下dp数组的状态变化，如下：

---

代码1

// 方式一：第一步不支付费用
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];
    }
}

代码2

// 方式二：第一步支付费用
class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int[] dp = new int[cost.length];
        dp[0] = cost[0];
        dp[1] = cost[1];

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

        //最后一步，如果是由倒数第二步爬，则最后一步的体力花费可以不用算
        return Math.min(dp[cost.length - 1], dp[cost.length - 2]);
    }
}