746. Min Cost Climbing Stairs C++题解_class solution {public: int mincostclimbingstairs(-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_43902431/article/details/105165138

本文探讨了一种经典的动态规划问题——最小成本爬楼梯。通过详细解析两种动态规划方法（常规DP和记忆化DP），帮助读者理解如何求解从楼梯底部到顶部的最低成本路径。文章提供了详细的代码实现，包括常规DP的滚动数组优化和记忆化DP的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

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].

解答一：常规DP

考虑前 $i$ 步的代价总和，为前 $i - 1$ 步加上 $c o s t [i - 1]$ 和前 $i - 2$ 步加上 $c o s t [i - 2]$ 之间的较小者。

由此可得递推公式为：dp[i]=min(dp[i-1]+cost[i-1],dp[(i-2]+cost[i-2])

代码如下：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int n = cost.size();
        if(n==0)return 0;
        if(n==1)return cost[0];
        if(n==2)return min(cost[0],cost[1]);
        int dp[n];
        dp[0]=0;dp[1]=0;
        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];
    }
};

优化：

可以发现时刻 $i$ 的状态仅与 $i - 1$ 和 $i - 2$ 时刻有关，就能用滚动数组的方式优化空间。

代码如下：

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

解答二：记忆化DP

刚学了记忆化，找个简单的题目练练手，直接上代码

class Solution {
public:
    int DP(int i,vector<int>& cost,int *dp,bool *vis)
    {
        int& d = dp[i];
        if(vis[i])return d;
        vis[i]=true;
        if(i==0)return d=0;
        if(i==1)return d=0;
        return d=min(DP(i-1,cost,dp,vis)+cost[i-1],DP(i-2,cost,dp,vis)+cost[i-2]);
    }
    int minCostClimbingStairs(vector<int>& cost) {
        const int n = cost.size();
        if(n==0)return 0;
        if(n==1)return cost[0];
        if(n==2)return min(cost[0],cost[1]);
        int dp[n+1];
        bool vis[n+1];
        fill_n(vis,n+1,false);
        dp[0]=0;dp[1]=0;
        return DP(n,cost,dp,vis);
    }
};