Min Cost Climbing Stairs - Practice Coding Problems

Min Cost Climbing Stairs - Problem

Imagine you're climbing a staircase where each step has a toll fee you must pay before moving forward. You're given an integer array cost where cost[i] represents the price to step on the i-th step.

Here's the twist: once you pay the cost for a step, you can either climb one step or two steps forward. You have the flexibility to start your journey from either step 0 or step 1 (both are free to start on).

Goal: Find the minimum cost to reach the "top of the floor" (which is one position beyond the last step in the array).

Example: If cost = [10, 15, 20], you want to reach position 3 (beyond the array). You could start at step 1 (cost 15), then jump 2 steps to reach the top, for a total cost of 15.

Input & Output

example_1.py — Small Staircase

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

› Output: 15

💡 Note: You can start at index 1 (cost 15), then jump 2 steps to reach the top. Total cost = 15. Alternative: start at index 0 (cost 10), jump 1 step to index 1 (cost 15), then jump 2 steps to top. Total cost = 10 + 15 = 25. Choose minimum: 15.

example_2.py — Longer Staircase

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

› Output: 6

💡 Note: Optimal path: Start at index 0 (cost 1) → jump 2 steps to index 2 (cost 1) → jump 2 steps to index 4 (cost 1) → jump 2 steps to index 6 (cost 1) → jump 2 steps to index 8 (cost 99) → jump 2 steps to top. Wait, that's wrong. Better path: 0→2→4→6→7→9→top costs 1+1+1+1+1+1=6.

example_3.py — Edge Case

$ Input: cost = [5, 10]

› Output: 5

💡 Note: With only 2 steps, we can start at either step 0 (cost 5) or step 1 (cost 10), then jump directly to the top. Choose the minimum starting cost: 5.

Constraints

2 ≤ cost.length ≤ 1000
0 ≤ cost[i] ≤ 999
You can start from step index 0 or 1
The "top of the floor" is one position beyond the last array element

Visualization

Tap to expand

Understanding the Visualization

Starting Options

You can begin your journey from the first or second bridge for free

Bridge Hopping

After paying a toll, you can cross to the next bridge OR skip one and go to the bridge after

Smart Choices

At each bridge, choose the cheaper of the two possible previous routes

Reach the Goal

Find the minimum total cost to reach the other side of the river

Key Takeaway

🎯 Key Insight: At each step, we only need to know the minimum cost to reach the previous two positions. This allows us to use dynamic programming with constant space complexity!

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses space-optimized dynamic programming with O(1) space complexity. Instead of storing all previous results, we only track the minimum costs for the last two steps using two variables. For each step, we calculate the minimum cost as cost[i] + min(prev1, prev2), then slide our window forward. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recursive)	O(2^n)	O(n)	Try all possible paths recursively and return the minimum cost
Space-Optimized DP (Optimal)	O(n)	O(1)	Use only two variables instead of full DP array to optimize space
Dynamic Programming (Bottom-Up)	O(n)	O(n)	Build up the solution from the bottom using tabulation

Brute Force (Recursive) — Algorithm Steps

Start from either step 0 or step 1
From each step, recursively try both 1-step and 2-step moves
Calculate the total cost for each complete path
Return the minimum cost among all possible paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Choices

We can begin from step 0 or step 1

Branch Out

From each step, we try both 1-step and 2-step moves

Overlap Problem

Same subproblems get calculated multiple times

Code -

solution.c — C

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

int climb(int* cost, int size, int i) {
    // Base cases: if we're at or past the top, no cost needed
    if (i >= size) {
        return 0;
    }
    
    // Try both 1-step and 2-step moves, take the minimum
    int oneStep = cost[i] + climb(cost, size, i + 1);
    int twoSteps = cost[i] + climb(cost, size, i + 2);
    
    return oneStep < twoSteps ? oneStep : twoSteps;
}

int minCostClimbingStairs(int* cost, int size) {
    // We can start from either step 0 or step 1
    int start0 = climb(cost, size, 0);
    int start1 = climb(cost, size, 1);
    
    return start0 < start1 ? start0 : start1;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int cost[100];
    int size = 0;
    
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        cost[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", minCostClimbingStairs(cost, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each position can branch into 2 recursive calls, creating a binary tree of depth n

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion call stack can go up to n levels deep

⚡ Linearithmic Space

82.3K 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

Brute Force (Recursive) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler