题目描述

On a staircase, the i-th step has some non-negative cost cost[i] assigned (0 indexed).

Once you pay the cost, you can either climb one or two steps. You need to find minimum cost to reach the top of the floor, and you can either start from the step with index 0, or the step with index 1.

Example 1:

Input: cost = [10, 15, 20]
Output: 15
Explanation: Cheapest is start on cost[1], pay that cost and go to the top.

Example 2:

Input: cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
Output: 6
Explanation: Cheapest is start on cost[0], and only step on 1s, skipping cost[3].

Note:

• cost will have a length in the range [2, 1000].
• Every cost[i] will be an integer in the range [0, 999].

题目思路

• 思路一、递归实现，超时，测试用例通过 256/276

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int a0 = fab(cost, 0);
        int a1 = fab(cost, 1);
        
        return a0 > a1 ? a1 : a0;
    }
    
    int fab(vector<int>& cost, int k){
        if(k >= cost.size()){
            return 0;
        }
        else{
            // 每次到达一个台阶，进行消费，可以向上爬一个或者两个台阶
            // 向上爬一个台阶
            int a = fab(cost, k+1);
            // 向上爬两个台阶
            int b = fab(cost, k+2);
            return a > b ? b+cost[k] : a+cost[k];
        }
    }
};

• 思路二、动态规划的思想，比递归方法卓越 参考

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

总结展望