Find Number of Ways to Reach the K-th Stair

Find Number of Ways to Reach the K-th Stair - Problem

Imagine Alice on a magical staircase that extends infinitely upward! 🏃‍♀️

Alice starts on stair 1 and wants to reach stair k. She has a special jump power that starts at 0 and increases with each upward move.

The Rules:

Down Move: From stair i, Alice can go down to stair i - 1 (but not from stair 0, and not twice in a row)
Up Move: From stair i, Alice can jump up to stair i + 2^jump, then her jump power increases by 1

Here's the twist: Alice can reach stair k multiple times using different paths! Your task is to count all possible ways she can reach stair k.

Example: If k=1, Alice starts at stair 1 (already there!), but she could also go up and come back down in various ways.

Input & Output

example_1.py — k = 0

$ Input: k = 0

› Output: 2

💡 Note: Alice starts at stair 1. She can reach stair 0 by going down once (1 way), or she can jump up to stair 2, then down to stair 1, then down to stair 0 (1 more way). Total: 2 ways.

example_2.py — k = 1

$ Input: k = 1

› Output: 4

💡 Note: Alice starts at stair 1 (1 way). She can also: jump to 2 then down to 1 (1 way), jump to 2 then 4 then down to 3 then down to 2 then down to 1 (1 way), and jump to 2 then 4 then down to 3 then down to 2 then jump to 3 then down to 2 then down to 1 (1 way). Total: 4 ways.

example_3.py — k = 2

$ Input: k = 2

› Output: 4

💡 Note: Alice can reach stair 2 by: jumping from 1 to 2 (1 way), going down from 1 to 0 then up to 1 then up to 2 (1 way), and other combinations involving multiple jumps and downs. Total: 4 ways.

Visualization

Tap to expand

Understanding the Visualization

Start Position

Alice begins on stair 1 with jump power 0

Down Move

Can go down 1 stair (but not consecutively or from stair 0)

Up Jump

Jump up 2^jump stairs, then jump power increases by 1

Count Paths

Every time Alice reaches stair k, count it as one valid path

Key Takeaway

🎯 Key Insight: The problem has optimal substructure - we can memoize states (position, jump_power, can_go_down) to avoid recalculating the same scenarios multiple times!

Time & Space Complexity

Time Complexity

⏱️

O(log²k)

Limited by the number of reachable states, which is logarithmic in k

⚡ Linearithmic

Space Complexity

O(log²k)

Memoization cache stores at most O(log²k) unique states

✓ Linear Space

Constraints

0 ≤ k ≤ 10⁹
Alice starts on stair 1
jump starts at 0
Cannot go down from stair 0
Cannot use down move consecutively

Asked in

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

The optimal approach uses memoized recursion to avoid recalculating the same states. Key insights: the state space is limited to O(log²k) unique combinations of (position, jump_power, can_go_down), and we can use mathematical properties to further optimize the solution.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Recursion	O(2^n)	O(n)	Explore all possible sequences of moves using recursion
Memoized Recursion (Optimal)	O(log²k)	O(log²k)	Use memoization to avoid recalculating the same states

Brute Force Recursion — Algorithm Steps

Start from position 1 with jump=0 and canGoDown=true
For each position, try going down if allowed (not consecutive, not from 0)
Try going up using 2^jump, incrementing jump power
Count each time we reach position k
Use recursion to explore all paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 1

Begin with jump=0, can go down

Branch on each move

Try both down and up moves when possible

Count target hits

Increment counter each time we reach k

Prune impossible paths

Stop when position becomes too large

Code -

solution.c — C

#include <stdio.h>

int dfs(int pos, int jump, int canGoDown, int k) {
    if (pos > k + 1) return 0;
    
    int ways = 0;
    if (pos == k) ways += 1;
    
    // Try going down
    if (canGoDown && pos > 0) {
        ways += dfs(pos - 1, jump, 0, k);
    }
    
    // Try going up
    ways += dfs(pos + (1 << jump), jump + 1, 1, k);
    
    return ways;
}

int waysToReachStair(int k) {
    return dfs(1, 0, 1, k);
}

int main() {
    int k;
    scanf("%d", &k);
    printf("%d\n", waysToReachStair(k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Each position can branch into up to 2 moves, leading to exponential growth

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth proportional to the number of moves

⚡ Linearithmic Space

Constraints

0 ≤ k ≤ 10⁹
Alice starts on stair 1
jump starts at 0
Cannot go down from stair 0
Cannot use down move consecutively

48.2K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler