Number of Ways to Stay in the Same Place After Some Steps

Number of Ways to Stay in the Same Place After Some Steps - Problem

Dynamic Programming Hard

Imagine you have a pointer starting at position 0 in an array of size arrLen. At each step, you can make one of three moves:

Move left (decrease position by 1)
Move right (increase position by 1)
Stay in the same position

Important: The pointer must never go outside the array bounds (positions 0 to arrLen-1).

Given steps total moves and array length arrLen, find the number of ways to end up back at position 0 after exactly steps moves.

Since the answer can be very large, return it modulo 10⁹ + 7.

Example: With steps = 3 and arrLen = 2, you could go: stay→stay→stay, or right→left→stay, etc.

Input & Output

example_1.py — Basic case

$ Input: steps = 3, arrLen = 2

› Output: 4

💡 Note: There are 4 different ways: 1) Stay-Stay-Stay, 2) Stay-Right-Left, 3) Right-Left-Stay, 4) Right-Stay-Left. All paths return to position 0 after exactly 3 steps.

example_2.py — Single position

$ Input: steps = 2, arrLen = 1

› Output: 1

💡 Note: With array length 1, we can only stay at position 0. There's only one way: Stay-Stay.

example_3.py — Large steps

$ Input: steps = 4, arrLen = 2

› Output: 8

💡 Note: Multiple combinations including: Stay-Stay-Stay-Stay, Right-Left-Stay-Stay, Stay-Right-Left-Stay, etc. All must end at position 0.

Visualization

Tap to expand

Understanding the Visualization

Starting Position

Robot starts at position 0 on the bridge

Available Moves

Each step: stay, move left, or move right (within bounds)

Build DP Table

Track ways to reach each position with each number of steps

Space Optimization

Only keep current and previous step data to save memory

Key Takeaway

🎯 Key Insight: We can optimize both time and space by recognizing that positions beyond 'steps' distance are unreachable, and we only need to store the previous step's results to compute the current step.

Time & Space Complexity

Time Complexity

⏱️

O(steps × min(steps, arrLen))

We iterate through each step and for each step, we process positions up to min(steps, arrLen) since we can't go further than steps distance from origin

✓ Linear Growth

Space Complexity

O(min(steps, arrLen))

We only store current and previous DP arrays, each of size min(steps, arrLen)

⚡ Linearithmic Space

Constraints

1 ≤ steps ≤ 500
1 ≤ arrLen ≤ 10⁶
Answer fits in 32-bit integer after modulo operation

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 31 f Meta 25

The optimal solution uses bottom-up dynamic programming with space optimization. Key insights: we only need to track positions within steps distance from origin, and we can optimize space by keeping only current and previous DP arrays. Time complexity: O(steps × min(steps, arrLen)), Space: O(min(steps, arrLen)).

Common Approaches

Approach	Time	Space	Notes
✓ Bottom-Up Dynamic Programming (Optimal)	O(steps × min(steps, arrLen))	O(min(steps, arrLen))	Build DP table bottom-up with space optimization using only current and previous row
Recursive Brute Force with Memoization	O(steps × min(steps, arrLen))	O(steps × min(steps, arrLen))	Use recursion to explore all possible paths with memoization to avoid recomputation

Bottom-Up Dynamic Programming (Optimal) — Algorithm Steps

Initialize dp array where dp[0] = 1 (1 way to stay at position 0 with 0 steps)
For each step from 1 to steps, create new dp array
For each position j, calculate ways from three possible previous positions
Optimize space by using only current and previous arrays
Return dp[0] after all steps (ways to be at position 0)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with dp[0] = 1, all others = 0

Fill each step

For each step, calculate ways to reach each position

Three transitions

Each position can come from left, right, or stay

Space optimization

Only keep current and previous arrays

Code -

solution.c — C

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

#define MOD 1000000007

int min(int a, int b) {
    return a < b ? a : b;
}

int numWaysToStayInSamePlace(int steps, int arrLen) {
    int maxPos = min(arrLen, steps + 1);
    
    int* prevDp = (int*)calloc(maxPos, sizeof(int));
    int* currDp = (int*)calloc(maxPos, sizeof(int));
    prevDp[0] = 1;
    
    for (int step = 0; step < steps; step++) {
        memset(currDp, 0, maxPos * sizeof(int));
        
        for (int pos = 0; pos < maxPos; pos++) {
            // Stay at current position
            currDp[pos] = (currDp[pos] + prevDp[pos]) % MOD;
            
            // Come from left position (if exists)
            if (pos > 0) {
                currDp[pos] = (currDp[pos] + prevDp[pos - 1]) % MOD;
            }
            
            // Come from right position (if exists)
            if (pos < maxPos - 1 && pos + 1 < arrLen) {
                currDp[pos] = (currDp[pos] + prevDp[pos + 1]) % MOD;
            }
        }
        
        int* temp = prevDp;
        prevDp = currDp;
        currDp = temp;
    }
    
    int result = prevDp[0];
    free(prevDp);
    free(currDp);
    return result;
}

int main() {
    int steps, arrLen;
    scanf("%d %d", &steps, &arrLen);
    printf("%d\n", numWaysToStayInSamePlace(steps, arrLen));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(steps × min(steps, arrLen))

We iterate through each step and for each step, we process positions up to min(steps, arrLen) since we can't go further than steps distance from origin

✓ Linear Growth

Space Complexity

O(min(steps, arrLen))

We only store current and previous DP arrays, each of size min(steps, arrLen)

⚡ Linearithmic Space

Constraints

1 ≤ steps ≤ 500
1 ≤ arrLen ≤ 10⁶
Answer fits in 32-bit integer after modulo operation

28.8K Views

Medium-High Frequency

~25 min Avg. Time

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

Bottom-Up Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler