leetcode刷题（746题）

746. 使用最小花费爬楼梯

数组的每个索引作为一个阶梯，第 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。

注意：

cost 的长度将会在 [2, 1000]。
每一个 cost[i] 将会是一个Integer类型，范围为 [0, 999]。

解决方案：

题目要求的是到达第n级台阶楼层顶部的最小花费，可以用动态规划来解，下面一步一步来讲怎样确定状态空间、怎样给出状态转移方程。

理解题意需要注意两点：

• 第i级台阶是第i-1级台阶的阶梯顶部。
• 踏上第i级台阶花费cost[i]，直接迈一大步跨过而不踏上去则不用花费。

解法一：

到达第i级台阶的阶梯顶部的最小花费，有两个选择：

1. 先付出最小总花费到达第i级台阶（即第i-1级台阶的阶梯顶部），踏上第i级台阶需要再花费，再迈一步到达第i级台阶的阶梯顶部，最小总花费为；
2. 先付出最小总花费到达第i-1级台阶（即第i-2级台阶的阶梯顶部），踏上第i-1级台阶需要再花费，再迈两步跨过第i级台阶直接到达第i级台阶的阶梯顶部，最小总花费为；

则minCost[i]是上面这两个最小总花费中的最小值。

台阶的数组从0开始计数。可以用-1代表地面，并设cost[-1] = 0。

最小总花费的初始值为：

第0级台阶： ，

第1级台阶： 。

动态递归代码如下：

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        n = len(cost)
        minCost = [0] * n
        minCost[1] = min(cost[0], cost[1])
        for i in range(2, n):
            minCost[i] = min(minCost[i - 1] + cost[i], minCost[i - 2] + cost[i - 1])
        return minCost[-1]

上面的代码在空间利用上可以再优化一下。只用两个变量保存状态转移方程中前面的两个记录，并不断更新，就可以递推下去，这样空间复杂度就由O(N)变为O(1)了。

代码如下：

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        minCost0, minCost1 = 0, min(cost[0], cost[1])
        for i in range(2, len(cost)):
            minCost = min(minCost1 + cost[i], minCost0 + cost[i - 1])
            minCost0, minCost1 = minCost1, minCost;
        return minCost

解法二：

到达第i级台阶的阶梯顶部的最小花费，有两个选择：

1. 最后踏上了第i级台阶，最小花费，再迈一步到达第i级台阶楼层顶部；
2. 最后踏上了第i-1级台阶，最小花费，再迈两步跨过第i级台阶直接到达第i级台阶的阶梯顶部。

所以到达第i级台阶的阶梯顶部的最小花费为。

踏上第i级台阶有两种方法：

1. 先踏上第i-2级台阶（最小总花费），再直接迈两步踏上第i级台阶（花费），最小总花费；
2. 先踏上第i-1级台阶（最小总花费），再迈一步踏上第i级台阶（花费），最小总花费；

则是上面这两个最小总花费中的最小值。

因此状态转移方程是：

。

初始条件：

最后一步踏上第0级台阶，最小花费。

最后一步踏上第1级台阶有两个选择：

1. 可以分别踏上第0级与第1级台阶，花费；
2. 也可以从地面开始迈两步直接踏上第1级台阶，花费。

最小值。

以下是代码：

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        n = len(cost)
        dp = [0] * n
        dp[0], dp[1] = cost[0], cost[1]
        for i in range(2, n):
            dp[i] = min(dp[i - 2], dp[i - 1]) + cost[i]
        return min(dp[-2], dp[-1])

上面的代码在空间利用上可以再优化一下。

注意到状态转移方程中只用到了前面的两个记录，可以不用一维数组，只用两个变量保存前面的两个记录，并不断更新，就可以递推下去，这样空间复杂度就是O(1)了。

更进一步，注意到初始值，，可以直接复用cost数组来代表dp数组。

代码如下：

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        for i in range(2, len(cost)):
            cost[i] = min(cost[i - 2], cost[i - 1]) + cost[i]
        return min(cost[-2], cost[-1])