题目描述

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

解题思路

求解登上台阶顶部的最小花费，台阶顶部为n，则可以转换为登上n-1和n-2时的最小花费+对应台阶的花费。满足求解最小子问题，即可以用动态规划来求解。

• cost数组长度为n，说明有n-1个台阶，n是顶峰。
• new一个dp数组，长度n+1，下标为n时，代表到达n时，最小的花费。
• 起始台阶可以是0或者1，则说明dp[0]=dp[1]=0
• dp[2]=Math.min(dp[0]+cost[0],dp[1]+cost[1])
• 可以得出状态转移方程为：dp[n]=Math.min(dp[n-2]+cost[n-2],dp[n-1]+cost[n-1])

java代码

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int n = cost.length;
        // dp数组
        int[] dp = new int[n + 1];
        dp[0] = dp[1] = 0;
        for (int i = 2; i <= n; i++) {
            dp[i] = Math.min(dp[i - 2] + cost[i - 2], dp[i - 1] + cost[i - 1]);
        }
        // 返回结果
        return dp[n];
    }
}

上述代码，空间复杂度为O(N)，可以发现，每次结果只是依赖于n-1和n-2的值，因此可以利用滚动数组的思想优化空间复杂度为O(1)。

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int n = cost.length;
        // 滚动数组
        int prev = 0, curr = 0;
        for (int i = 2; i <= n; i++) {
            int next = Math.min(prev + cost[i - 2], curr + cost[i - 1]);
            prev = curr;
            curr = next;
        }
        return curr;
    }
}

复杂度

• 时间复杂度：O(N)
• 空间复杂度：O(1)