【Day 54 】2022-05-24 - 746.使用最小花费爬楼梯

[azl397985856]

746.使用最小花费爬楼梯

入选理由

暂无

题目地址

https://leetcode-cn.com/problems/min-cost-climbing-stairs/

前置知识

• 动态规划

  题目描述

  
  数组的每个下标作为一个阶梯，第 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] 将会是一个整型数据，范围为 [0, 999] 。

[Jongeehsu]

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

[xixiao51]

Idea

Dynamic programming

Code

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

Complexity Analysis

• Time complexity: O(N)
• Space complexity: O(N)

[TonyLee017]

思路

• 动态规划

  代码

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

  复杂度分析

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

[gitbingsun]

题目地址(746. 使用最小花费爬楼梯)

https://leetcode.cn/problems/min-cost-climbing-stairs/

题目描述

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

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

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

 

示例 1：

输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。
- 支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15 。

示例 2：

输入：cost = [1,100,1,1,1,100,1,1,100,1]
输出：6
解释：你将从下标为 0 的台阶开始。
- 支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。
- 支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。
- 支付 1 ，向上爬一个台阶，到达楼梯顶部。
总花费为 6 。

 

提示：

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

前置知识

动态规划。也可以用两个变量代替一个动态数组。

class Solution { / dp[i] -- the min cost to reach ith step and do not need pay for the ith stair / public: int minCostClimbingStairs(vector& cost) { int n = cost.size(); vector dp(n+1, 0);

    for (int i = 2; i < dp.size(); i++) {
        dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2]); // take 1 or 2 steps
    }

    return dp[n];
}

};

**复杂度分析**

令 n 为数组长度。

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