算法 LC 使用最小花费爬楼梯

题目描述

给你一个整数数组 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 。

题解

思路1: 动态规划
dp[i] 表示爬上第i阶台阶的最低花费
动态转移方程为： dp[i] = min(dp[i-1],dp[i-2]) + cost[i]
边界条件: dp[0] = cost[0] dp[1] = cost[1]
登顶的最低花费为min(dp[n-1], dp[n-2])

   static public func minCostClimbingStairs1(_ cost: [Int]) -> Int {
       let n = cost.count;
       if n == 0 {return 0}
       if n == 1 {return 0}
       if n == 2 {return min(cost[0], cost[1])}
       
       var dp = Array(repeating: Int.max, count: n)
       dp[0] = cost[0]
       dp[1] = cost[1]
       
       for i in 2..

思路2: 动态规划
dp[i] 表示达到楼梯顶部i的最低花费
动态转移方程为： dp[i] = min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2])
边界条件: dp[0] = 0 dp[1] = 0
登顶的最低花费为dp[n]

    static public func minCostClimbingStairs2(_ cost: [Int]) -> Int {
        let n = cost.count;
        if n == 0 {return 0}
        if n == 1 {return 0}
        if n == 2 {return min(cost[0], cost[1])}
        
        var dp = Array(repeating: Int.max, count: n+1)
        dp[0] = 0
        dp[1] = 0
        
        for i in 2..<(n+1) {
            dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2])
        }
        
        return dp[n]

     }

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