Min Cost Climbing Stairs

Min Cost Climbing Stairs - Problem

You are given an integer array cost where cost[i] is the cost of the i-th step on a staircase. Once you pay the cost, you can either climb one or two steps.

You can either start from the step with index 0, or the step with index 1.

Return the minimum cost to reach the top of the floor.

Input & Output

Example 1 — Basic Case

$ Input: cost = [10, 15, 20]

› Output: 15

💡 Note: You can start at index 1 (cost 15) and jump directly to the top, avoiding the more expensive paths through step 0 or step 2.

Example 2 — Multiple Steps

$ Input: cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]

› Output: 6

💡 Note: Start at index 0, jump to index 2, then 4, 6, 8, and finally to the top. Total cost: 1+1+1+1+1+1 = 6.

Example 3 — Minimum Size

$ Input: cost = [5, 10]

› Output: 5

💡 Note: Start at index 0 (cost 5) and jump directly to the top, which is cheaper than starting at index 1 (cost 10).

Constraints

2 ≤ cost.length ≤ 1000
0 ≤ cost[i] ≤ 999

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 M Microsoft 32 🍎 Apple 28

The key insight is that at each step, we choose the cheaper of the two previous steps. The space-optimized DP approach is optimal with Time: O(n), Space: O(1).

Common Approaches

✓ 1D Dynamic Programming

⏱️ Time: O(n) Space: O(n)

Build up the solution from bottom to top using a DP array. For each step, calculate the minimum cost by considering the cheaper of the two previous steps. This eliminates recursion overhead.

Memoization (Top-Down DP)

⏱️ Time: O(n) Space: O(n)

Same recursive approach but store results of subproblems in a memo table. When we need to calculate cost for a step we've seen before, return the cached result instead of recalculating.

Recursive Brute Force

⏱️ Time: O(2ⁿ) Space: O(n)

For each step, recursively calculate the minimum cost by trying both one-step and two-step jumps. This explores all possible combinations but recalculates the same subproblems multiple times.

Space-Optimized DP

⏱️ Time: O(n) Space: O(1)

Since we only need the previous two steps to calculate the current step, we can optimize space by using just two variables instead of a full array. This gives the same time complexity but with constant space.

1D Dynamic Programming — Algorithm Steps

Create DP array where dp[i] = min cost to reach step i
Fill array: dp[i] = cost[i] + min(dp[i-1], dp[i-2])
Return minimum of last two positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[0] and dp[1] to their respective costs

Fill DP

For each step, choose cheaper previous path

Final Answer

Return minimum of last two DP values

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

int solution(int* cost, int size) {
    if (size <= 2) {
        return cost[0] < cost[1] ? cost[0] : cost[1];
    }
    
    int* dp = (int*)malloc(size * sizeof(int));
    dp[0] = cost[0];
    dp[1] = cost[1];
    
    for (int i = 2; i < size; i++) {
        dp[i] = cost[i] + (dp[i-1] < dp[i-2] ? dp[i-1] : dp[i-2]);
    }
    
    int result = dp[size-1] < dp[size-2] ? dp[size-1] : dp[size-2];
    free(dp);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int cost[1000];
    int size = 0;
    
    // Skip opening bracket
    char* ptr = strchr(line, '[');
    if (ptr) ptr++;
    
    char* token = strtok(ptr, ",]");
    while (token != NULL && size < 1000) {
        // Skip whitespace
        while (*token && isspace(*token)) token++;
        if (*token) {
            cost[size++] = atoi(token);
        }
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(cost, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to fill DP table

✓ Linear Growth

Space Complexity

O(n)

DP array stores minimum cost for each step

⚡ Linearithmic Space

85.0K Views

High Frequency

~15 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

1D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler