746. 使用最小花费爬楼梯

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

 

思路

1. 确定dp数组以及下标的含义

使用动态规划，就要有一个数组来记录状态，本题只需要一个一维数组dp[i]就可以了。

dp[i]的定义：到达第i+1个台阶的cost，如果cost数组长度为3，那么楼顶就是3，最后返回dp[2]即可，dp[2]就代表到达第三个台阶（楼顶）的cost。

2. 确定递推公式

可以有两个途径得到dp[i]，一个是dp[i-1] 一个是dp[i-2]。

dp[i - 1] 代表已经到了第i个台阶，dp[i]代表跳到第i+1个台阶，因此dp[i - 1] 到 dp[i] 需要花费 dp[i - 1] + cost[i]。那么dp[i - 2] 到 dp[i] 需要花费 dp[i - 2] + cost[i - 1]。

那么究竟是选从dp[i - 1]跳还是从dp[i - 2]跳呢？

一定是选最小的，所以dp[i] = min(dp[i - 1] + cost[i], dp[i - 2] + cost[i - 1]);

3. dp数组如何初始化

dp[0]代表到第一层，要么从0开始到1，要么直接站到第一层，所以dp[0] = 0，dp[1]代表到了第二层，要么从0到2，要么从1到2，所以dp[1] = min(cost[0],cost[1])。

4. 确定遍历顺序

最后一步，递归公式有了，初始化有了，如何遍历呢？

因为是模拟台阶，而且dp[i]由dp[i-1]dp[i-2]推出，所以是从前到后遍历cost数组就可以了。

但是稍稍有点难度的动态规划，其遍历顺序并不容易确定下来。 例如：01背包，都知道两个for循环，一个for遍历物品嵌套一个for遍历背包容量，那么为什么不是一个for遍历背包容量嵌套一个for遍历物品呢？ 以及在使用一维dp数组的时候遍历背包容量为什么要倒序呢？

5. 举例推导dp数组

就拿10，15，20举例，dp[0] = 0，dp[1] = min(cost[0],cost[1]) = 10，然后求dp[2],要么从第二层跳。要么从第一层跳，因此dp[2] = min(dp[1]+cost[2],dp[0]+cost[1])

代码如下：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int> dp(cost.size()); //dp[n]，n+1层为楼顶的代价
        if(cost.size()==0||cost.size()==1)
        {
            return 0;
        }
        dp[0]=0;
        dp[1]=min(cost[0],cost[1]);
        for(int i=2;i<cost.size();i++)
        {
            dp[i]=min(dp[i-1]+cost[i],dp[i-2]+cost[i-1]);
        }
        return dp[cost.size()-1];
    }
};

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

还可以优化空间复杂度，因为dp[i]就是由前两位推出来的，那么也不用dp数组了，C++代码如下：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int dp[2];
        if(cost.size()==0||cost.size()==1)
        {
            return 0;
        }
        dp[0]=0;
        dp[1]=min(cost[0],cost[1]);
        for(int i=2;i<cost.size();i++)
        {            
            int result = min(dp[1]+cost[i],dp[0]+cost[i-1]);
            dp[0]=dp[1];
            dp[1]=result;
        }
        return dp[1];
    }
};

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

当然如果在面试中，能写出版本一就行，除非面试官额外要求 空间复杂度，那么再去思考版本二，因为版本二还是有点绕。版本一才是正常思路。