This approach uses a dynamic programming table to store the minimum cost at each step. The key idea is that to reach step i, you can come from step i-1 or step i-2, and you need to pay the cost associated with landing on step i. Thus, the cost to reach step i is the minimum of the cost to reach steps i-1 or i-2 plus cost[i]. The solution returns the minimum cost to reach the top from the last two steps.
Time Complexity: O(n), where n is the number of steps as we traverse the list once.
Space Complexity: O(n), as we need an additional array to store minimum costs at each step.
1#include <vector>
2#include <algorithm>
3using namespace std;
4
5int minCostClimbingStairs(vector<int>& cost) {
6 vector<int> dp(cost.size() + 1);
7 dp[0] = cost[0];
8 dp[1] = cost[1];
9 for (int i = 2; i < cost.size(); i++) {
10 dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
11 }
12 return min(dp[cost.size() - 1], dp[cost.size() - 2]);
13}This solution mirrors the C solution, but uses C++ vector operations for dynamic programming. This vector is filled with the minimum cost to reach each step by considering the two previous steps. The minimum of the last two values in the vector represents the minimum cost to reach the top of the stairs.
This approach optimizes the space usage of the dynamic programming solution by only retaining two variables to store the minimal costs for the last two steps, instead of an entire table. This is possible because each step's cost only depends on the previous two calculations. You update these two variables iteratively to find the minimum cost to reach the top.
Time Complexity: O(n)
Space Complexity: O(1)
1#include <stdio.h>
2
3int minCostClimbingStairs(int* cost, int costSize) {
4 int prev = cost[0];
5 int curr = cost[1];
6 for (int i = 2; i < costSize; i++) {
7 int next = (prev < curr ? prev : curr) + cost[i];
8 prev = curr;
9 curr = next;
10 }
11 return (prev < curr ? prev : curr);
12}This C solution reduces space by using two variables, prev and curr, to store the two previous minimum costs. As it iterates through the cost array, it updates these variables based on their minimum and the current cost. Finally, it returns the minimum of the last two values stored in prev and curr.