Climbing Stairs

Climbing Stairs - Problem

You are climbing a staircase. It takes n steps to reach the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Note: Given n will be a positive integer.

Input & Output

Example 1 — Small Staircase

$ Input: n = 2

› Output: 2

💡 Note: There are two ways to climb to the top: 1. 1 step + 1 step, 2. 2 steps

Example 2 — Medium Staircase

$ Input: n = 3

› Output: 3

💡 Note: There are three ways: 1. 1+1+1 steps, 2. 1+2 steps, 3. 2+1 steps

Example 3 — Single Step

$ Input: n = 1

› Output: 1

💡 Note: Only one way to climb 1 step: take 1 step

Constraints

1 ≤ n ≤ 45

Visualization

Tap to expand

Asked in

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

The key insight is recognizing this follows the Fibonacci pattern: to reach step n, you can come from step n-1 (take 1 step) or step n-2 (take 2 steps). Best approach is space-optimized DP using two variables. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Recursion

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

Use recursion to count all possible ways to reach the top. For each position, we can either take 1 step or 2 steps, leading to two recursive calls.

Dynamic Programming (Bottom-Up)

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

Use bottom-up dynamic programming to build the solution iteratively. Start with base cases and compute each value using previously calculated results.

Memoization (Top-Down DP)

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

Use memoization to store previously calculated results. This transforms the exponential time complexity into linear by ensuring each subproblem is solved only once.

Space-Optimized DP

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

Since we only need the previous two values to calculate the current value, we can optimize space by using just two variables instead of the entire DP array.

Brute Force Recursion — Algorithm Steps

Start from step n
At each step, try both 1-step and 2-step moves
Base cases: 1 way to reach step 1, 2 ways to reach step 2
Sum up all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at step n and branch into n-1 and n-2

Recurse

Continue branching until base cases

Sum

Add up all valid paths

Code -

solution.c — C

#include <stdio.h>

int solution(int n) {
    if (n <= 2) {
        return n;
    }
    return solution(n - 1) + solution(n - 2);
}

int main() {
    int n;
    scanf("%d", &n);
    int result = solution(n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Each call branches into two recursive calls, creating a binary tree of depth n

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels deep

⚡ Linearithmic Space

311.6K Views

Very High Frequency

~15 min Avg. Time

8.4K 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 Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler