746. Min Cost Climbing Stairs C++题解

题目

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

解答一：常规DP

考虑前$i$步的代价总和，为前$i-1$步加上$cost[i-1]$ 和前$i-2$步加上$cost[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);
    }
};