​Leetcode 746. 使用最小花费爬楼梯​ 入门dp C++实现

问题：Leetcode 746. 使用最小花费爬楼梯

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

---

算法1：递归

        因为要解决的问题都是「从 0 或 1 爬到  i 」，所以定义 dfs ( i ) 表示从 0 或 1 爬到 i 的最小花费。

枚举最后一步爬了几个台阶，分类讨论：

        如果最后一步爬了 1 个台阶，那么我们得先爬到 i − 1，要解决的问题缩小成：从 0 或 1 爬到 i − 1 的最小花费。把这个最小花费加上 cost [ i − 1 ] ，就得到了 dfs ( i ) ，即 dfs ( i ) = dfs ( i − 1 ) + cost [ i − 1 ] 。
        如果最后一步爬了 2 个台阶，那么我们得先爬到 i − 2，要解决的问题缩小成：从 0 或 1 爬到 i − 2 的最小花费。把这个最小花费加上 cost [ i − 2 ] ，就得到了 dfs ( i ) ，即 dfs ( i ) = dfs ( i − 2 ) + cost [ i − 2 ] 。
        这两种情况取最小值，就得到了从 0 或 1 爬到 i 的最小花费，即dfs ( i ) = min ( dfs ( i − 1 ) + cost [ i − 1 ] , dfs ( i − 2 ) + cost [ i − 2 ] )
        递归边界：dfs ( 0 ) = 0, dfs ( 1 ) = 0。爬到 0 或 1 无需花费，因为我们一开始在 0 或 1。

        递归入口：dfs ( n )，也就是答案。

代码：

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

---

算法2：递归 + 记录返回值 = 记忆化搜索

        注意到「先爬 1 个台阶，再爬 2 个台阶」和「先爬 2 个台阶，再爬 1 个台阶」，都相当于爬 3 个台阶，都会从 dfs ( i ) 递归到 dfs ( i  − 3 ) 。

        一叶知秋，整个递归中有大量重复递归调用（递归入参相同）。由于递归函数没有副作用，同样的入参无论计算多少次，算出来的结果都是一样的，因此可以用记忆化搜索来优化：

        如果一个状态（递归入参）是第一次遇到，那么可以在返回前，把状态及其结果记到一个 memo 数组中。
        如果一个状态不是第一次遇到（memo 中保存的结果不等于 memo 的初始值），那么可以直接返回 memo 中保存的结果。
        注意：memo 数组的初始值一定不能等于要记忆化的值！例如初始值设置为 0，并且要记忆化的 dfs ( i ) 也等于 0，那就没法判断 0 到底表示第一次遇到这个状态，还是表示之前遇到过了，从而导致记忆化失效。一般把初始值设置为 −1。

代码：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int n = cost.size();
        vector<int> memo(n + 1,-1);
        function<int(int)>dfs = [&](int i)->int{
            if(i <= 1) return 0;
            int& res = memo[i];
            if(res != -1)   return memo[i];
            return res = min(cost[i - 1] + dfs(i - 1),cost[i - 2] + dfs(i - 2));
        };
    return dfs(n);
    }
};

---

算法3：1:1 翻译成递推

我们可以去掉递归中的「递」，只保留「归」的部分，即自底向上计算。

具体来说，dp [ i ] 的定义和 dfs ( i ) 的定义是一样的，都表示从 0 或 1 爬到 i 的最小花费。

相应的递推式（状态转移方程）也和 dfs 一样：dp [ i ] = min ( dp [ i − 1 ] + cost [ i − 1 ] , dp [ i − 2 ] + cost [ i − 2 ] )
相当于之前是用递归去计算每个状态，现在是枚举并计算每个状态。

初始值 dp [ 0 ] = 0, dp [ 1 ] = 0 ，翻译自递归边界 dfs ( 0 ) = 0 , dfs ( 1 ) = 0 。

答案为 dp [ n ] ，翻译自递归入口 dfs ( n ) 。

代码：

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

---

算法4：空间优化

        观察状态转移方程，发现一旦算出 dp [ i ] ，那么 dp [ i − 2 ] 及其左边的状态就永远不会用到了。

        这意味着每次循环，只需要知道「上一个状态」和「上上一个状态」的 f 值是多少，分别记作dp1​ 和 dp0​ 。它俩的初始值均为 0，对应着 dp [ 1 ] 和 dp [  0 ] 。

        每次循环，计算出新的状态 newdp = min ( dp1 +cost [ i − 1 ] , dp0​ + cost [ i − 2 ] ) ，那么对于下一轮循环来说：「上上一个状态」就是 dp1 ​更新 dp0 = dp1 。「上一个状态」就是 newdp ，更新 dp1​ = newdp 。
        最后答案为 dp1 ，因为最后一轮循环算出的 newdp 赋给了 dp1​ 。代码实现时，可以把 i 改成从 1 遍历到 n−1，这样 newdp = min ( dp1​ + cost [ i ] , dp0 + cost [ i − 1 ] ) ，可以简化一点代码。

代码：

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