【算法修炼道路】使用最小花费爬楼梯

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/min-cost-climbing-stairs
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

关键字：动态规划

思路比较简单，直接上代码。代码一共提交了N多版，主要是效率优化问题。

一、这是第一版代码，没好好优化的问题，写完跑几组数据，直接提交了，运行结果如下发现运行得比较慢，排名特别靠后（但是最终发现，其实没多少差别）

这段代码逻辑过于冗余，很多条件判断是没有必要的，可以删减掉一些逻辑，于是有了第二版代码

执行用时: 12 ms

内存消耗: 13.5 MB

提交时间：11 分钟前

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        if (2 > cost.size()) {
            return 0;
        }
        else if (2 == cost.size()) {
            return cost[0] > cost[1] ? cost[1] : cost[2];
        }
        int minCost = -1;
        for (int i=0; i<cost.size() + 1; ++i) {
            if (i == cost.size()) {
                minCost = cost[i-1] > cost[i-2] ? cost[i-2] : cost[i-1];
            }
            else if (i == 0) {
                cost[i] = cost[i];
            }
            else if (i == 1) {
                cost[i] = cost[1];
            }
            else {
                int step1 = cost[i-2] + cost[i];
                int step2 = cost[i-1] + cost[i];
                cost[i] = step1 > step2 ? step2 : step1;
            }
            
        }

        return minCost;
    }
};

二、这里是第二版代码，优化了一些条件判断，同时比上一版精简了很多，提交了很多次，其实运行效率也没快多少，排名依旧不上不下

主要是精简了判断逻辑，因为当i<2的时候，始终返回的是0，而当i=2的时候，就可以带入动态方程

最后翻了评论，有大佬说超过了99+%的人，于是我看了一下，第三版代码是别人写的，只用了3行

执行用时: 8 ms

内存消耗: 13.5 MB

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

        return minCost;
    }
};

三、这是大佬的三行代码

我用这个代码提交了几次，运行效率确实快了很多，有一次运行效率显示0ms（这是真实存在的嘛。。。？）

但是不得不说，这个确实够精简！

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