剑指 Offer II 088. 爬楼梯的最少成本（简单 动态规划 数组）

剑指 Offer II 088. 爬楼梯的最少成本

数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值 cost[i]（下标从 0 开始）。

每当爬上一个阶梯都要花费对应的体力值，一旦支付了相应的体力值，就可以选择向上爬一个阶梯或者爬两个阶梯。

请找出达到楼层顶部的最低花费。在开始时，你可以选择从下标为 0 或 1 的元素作为初始阶梯。

示例 1：

输入：cost = [10, 15, 20]
输出：15
解释：最低花费是从 cost[1] 开始，然后走两步即可到阶梯顶，一共花费 15 。
示例 2：

输入：cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
输出：6
解释：最低花费方式是从 cost[0] 开始，逐个经过那些 1 ，跳过 cost[3] ，一共花费 6 。

提示：

2 <= cost.length <= 1000
0 <= cost[i] <= 999

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/GzCJIP
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

方法一：递归
动态规划题，我们知道爬楼梯每次可以选择爬1层或者2层，那么每次进行爬楼梯的时候都要进行两次考虑。
1、找出状态转移方程：假设要爬到第 i 层，前两层的最优爬法分别以f(i - 1)和f(i - 2)表示，那么爬到第 i 层的最优爬法就是f(i) = min(f(i - 1), f(i - 2)) + cost[ i ]，对于 i 小于2的情况 f(0) = cost[0]，f(1) = cost[1]。
2、递归的方法是利用自上而下的做法，即从 cost.length 往下走，直到cost[0]或者cost[1]返回，为了避免重复递归，利用 dp[] 来对走过的路进行缓存，即 dp[i] 表示 f(i) 。
3、递归的方法时间复杂度是O(n)空间复杂度是O(n)。
方法二： 迭代
迭代的方法时间复杂度和空间复杂度跟方法一相同。
迭代是利用自下而上的方法，从 f(0) 和 f(1) 开始构建 dp[] 数组。
方法三：空间复杂度为O(1)的迭代
从状态转移方程可以看出我们只需要f(i - 1)和f(i - 2)就可以得到f(i)，那么我们只需要动态调整f(i - 1)和f(i - 2)的值即可，也就是说dp[]数组里只存储2个元素就够了。

题解（Java）

方法一：递归

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int length = cost.length;
        int[] dp = new int[length];
        // 考虑到length如果是2，dp[0]在递归过程中不会赋值，所以提前赋值
        dp[0] = cost[0];
        helper(cost, length - 1, dp);
        return Math.min(dp[length - 2], dp[length - 1]);
    }

    private void helper(int[] cost, int i, int[] dp) {
        if (i < 2) {
            dp[i] = cost[i];
        } else if (dp[i] == 0) {
            helper(cost, i - 2, dp);
            helper(cost, i - 1, dp);
            dp[i] = Math.min(dp[i - 2], dp[i - 1]) + cost[i];
        }
    }
}

方法二：迭代

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

方法三：迭代优化

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int[] dp = {cost[0], cost[1]};
        for (int i = 2; i < cost.length; i++) {
            dp[i % 2] = Math.min(dp[0], dp[1]) + cost[i];
        }
        return Math.min(dp[0], dp[1]);
    }
}