Out of Boundary Paths - Practice Coding Problems

Out of Boundary Paths - Problem

Dynamic Programming Medium

Out of Boundary Paths - Find the number of ways a ball can escape from a grid

Imagine you have a ball placed on an m × n grid at position [startRow, startColumn]. The ball can move in four directions (up, down, left, right) to adjacent cells, and importantly, it can also move outside the grid boundaries to escape!

You're given a maximum of maxMove moves to work with. Your task is to count all possible paths that lead the ball out of the grid boundary within the move limit.

Key Points:
• The ball starts at [startRow, startColumn]
• Each move allows the ball to go to any adjacent cell (including out of bounds)
• Moving out of bounds counts as an escape path
• You can use at most maxMove moves
• Return the count modulo 10^9 + 7

Example: In a 2×3 grid starting at [0,1] with 2 moves, the ball could escape by going up (1 move) or left then up (2 moves), among other paths.

Input & Output

example_1.py — Small Grid

$ Input: [2, 3, 3, 0, 1]

› Output: 12

💡 Note: In a 2×3 grid starting at [0,1] with 3 moves, there are 12 different paths that lead the ball out of the grid boundary. The ball can escape by moving up (1 move), or various combinations of left/right then up/down.

example_2.py — Single Move

$ Input: [1, 3, 3, 0, 1]

› Output: 12

💡 Note: In a 1×3 grid starting at [0,1] with 3 moves, the ball is in the middle column. It can escape up or down in 1 move, or move left/right first then escape. Multiple paths exist due to the move flexibility.

example_3.py — No Escape

$ Input: [10, 10, 0, 5, 5]

› Output: 0

💡 Note: With 0 moves allowed, the ball cannot move at all, so there are 0 paths to escape the grid boundary.

Constraints

1 ≤ m, n ≤ 50
0 ≤ maxMove ≤ 50
0 ≤ startRow < m
0 ≤ startColumn < n
Answer must be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Setup

Place ball at starting position [startRow, startColumn] on m×n grid

Explore Moves

From each position, ball can move up, down, left, or right

Count Escapes

Moving out of grid boundaries counts as one escape path

Memoize

Cache results for each (row, col, moves) state to avoid recalculation

Sum Paths

Total all possible escape paths within move limit

Key Takeaway

🎯 Key Insight: The number of escape paths from any position depends only on current coordinates and remaining moves - making this perfect for memoization to avoid exponential recalculation!

Asked in

G Google 28 a Amazon 22 f Facebook 18 ⊞ Microsoft 15

The optimal solution uses dynamic programming with memoization to count escape paths efficiently. Instead of exploring all 4^maxMove possible move sequences, we cache results for each unique state (position + remaining moves), reducing complexity to O(m × n × maxMove). The key insight is that the number of escape paths from any position depends only on the current location and moves remaining.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(m * n * maxMove)	O(m * n * maxMove)	Cache results to avoid recomputing the same subproblems
Recursive Brute Force	O(4^maxMove)	O(maxMove)	Explore all possible move sequences recursively

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Create a memoization cache (dictionary/map)
For each recursive call, check if result already exists in cache
If cached, return the stored result immediately
If not cached, compute result recursively and store in cache
Return the final count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

First Calculation

Compute paths from position (1,1) with 2 moves

Cache Result

Store result in memo[(1,1,2)] = 4

Cache Hit

When same state appears again, return cached value

Efficiency Gain

Avoid exponential recalculation

Code -

solution.c — C

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

const int MOD = 1000000007;
const int MAXSIZE = 10000;

typedef struct {
    char key[50];
    int value;
} MemoItem;

MemoItem memo[MAXSIZE];
int memoSize = 0;

int findInMemo(const char* key) {
    for (int i = 0; i < memoSize; i++) {
        if (strcmp(memo[i].key, key) == 0) {
            return memo[i].value;
        }
    }
    return -1;
}

void addToMemo(const char* key, int value) {
    if (memoSize < MAXSIZE) {
        strcpy(memo[memoSize].key, key);
        memo[memoSize].value = value;
        memoSize++;
    }
}

int dfs(int m, int n, int row, int col, int moves) {
    // Base case: out of bounds - found a path
    if (row < 0 || row >= m || col < 0 || col >= n) {
        return 1;
    }
    
    // Base case: no moves left
    if (moves == 0) {
        return 0;
    }
    
    // Check memoization
    char key[50];
    sprintf(key, "%d,%d,%d", row, col, moves);
    int cached = findInMemo(key);
    if (cached != -1) {
        return cached;
    }
    
    // Explore all 4 directions
    long long paths = 0;
    int directions[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    
    for (int i = 0; i < 4; i++) {
        paths = (paths + dfs(m, n, row + directions[i][0], col + directions[i][1], moves - 1)) % MOD;
    }
    
    // Store in memo
    addToMemo(key, (int)paths);
    return (int)paths;
}

int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
    memoSize = 0;
    return dfs(m, n, startRow, startColumn, maxMove);
}

int main() {
    int m, n, maxMove, startRow, startColumn;
    scanf("[%d, %d, %d, %d, %d]", &m, &n, &maxMove, &startRow, &startColumn);
    printf("%d\n", findPaths(m, n, maxMove, startRow, startColumn));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * n * maxMove)

Each unique state (row, col, moves) is computed only once, and there are m*n*maxMove possible states

✓ Linear Growth

Space Complexity

O(m * n * maxMove)

Memoization cache stores results for each unique state, plus recursion stack space

⚡ Linearithmic Space

58.0K Views

Medium Frequency

~25 min Avg. Time

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

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler