LeetCode746 Min Cost Climbing Stairs（爬上楼梯的最小损失）

题目

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:

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

解法

这是一个动态规划问题，按照以下步骤来解决

1. 分析最优解的性质。并刻画其结构特征。

求最终的最小cost， 因为到最后的cost可以表示为

max(走到最后一层楼梯的最小cost,走到最后二层楼梯的最小cost)

2. 递归的定义最优解

递推定义：

cost = min（上一层的最小cost + 当前层cost, 上两层的最小cost + 当前层cost）

3. 以自底向上或自顶向下的记忆化方式（备忘录法）计算出最优值。

我们需要记录每一层的最优值（最小cost）

定义stairCost数组 stairCost[i]表示走到第i层的最小cost

递推改为：

stairCost[i] = min(stairCost[i-2] + cost[i], stairCost[i-1] + cost[i]);

4 .依据计算最优值时得到的信息，构造问题的最优解。

最优解可以表示为

 min(stairCost[cost.size()-2] , stairCost[cost.size()-1]);

代码及注释

解法1：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        //定义一个数组 表示爬上每一层楼梯 需要的最少cost
        vector<int> stairCost(cost.size(), 0);
        //第一层楼梯和第二层楼梯的cost就是本身
        stairCost[0] = cost[0];
        stairCost[1] = cost[1];
        //现在循环计算 后面每一层的最小cost

        for (int i = 2; i < cost.size(); i++) {
            stairCost[i] = min(stairCost[i-2] + cost[i], stairCost[i-1] + cost[i]);
        }

        //到达楼梯终点的最小cost 就是倒数第一层和第二层的最小cost值
        return min(stairCost[cost.size()-2] , stairCost[cost.size()-1]);
    }
};

扩展

还有一些非常类似的题目， 有异曲同工之妙

1. LeetCode70——Climbing Stairs

题目如下

You are climbing a stair case. It takes n steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Note: Given n will be a positive integer.

Example 1:

Input: 2
Output: 2
Explanation: There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps

Example 2:

Input: 3
Output: 3
Explanation: There are three ways to climb to the top.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step

题目设定都差不多，都是一次只能爬一层或者两次， 问爬到终点的方法共有几种？

当楼梯层数大于2时， 到达当前位置的走法可以表示为：

total_way[n] = total_way [n - 1] + total_way [n - 2]
因为到达楼梯方式有两种， 一种是从前面一层走一步过来， 另外一种是从前面两层走两步过来， 总方法 就是两者之和

其次是目标解 可以表示为最后一层的方法数

代码如下

class Solution {
public:
    int climbStairs(int n) {
        //特殊数据处理  当n为 1 或 2时， 返回 1 和 2
        if (n <= 2) {
            return n;
        }
        //创建数组 用了保存走到当前位置共需要的方法
        int * total_way = new int[n];
        //初始化条件 
        //走到第一层一种走法
        total_way[0] = 1;
        //走到第二层要两种走法
        total_way[1] = 2;        
        //循环递推求解
        for (int i = 2; i < n; i++){
            //递推式
            total_way[i] = total_way[i - 2] + total_way[i - 1];
        }
        //目的解就是走到最后一块的走法
        return  total_way[n - 1];

    }
};