Out of Boundary Paths

Out of Boundary Paths - Problem

Dynamic Programming Medium

There is an m x n grid with a ball. The ball is initially at the position [startRow, startColumn]. You are allowed to move the ball to one of the four adjacent cells in the grid (possibly out of the grid crossing the grid boundary). You can apply at most maxMove moves to the ball.

Given the five integers m, n, maxMove, startRow, startColumn, return the number of paths to move the ball out of the grid boundary. Since the answer can be very large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Small Grid

$ Input: m = 2, n = 3, maxMove = 2, startRow = 1, startColumn = 1

› Output: 6

💡 Note: From center position (1,1), the ball can exit the boundary in 6 different ways within 2 moves: moving up-up, up-left, up-right, down-down, down-left, down-right

Example 2 — Single Move

$ Input: m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1

› Output: 12

💡 Note: From middle of 1x3 grid, ball can exit left or right in 1 move (2 ways), or make more complex paths using all 3 moves for total of 12 paths

Example 3 — No Moves

$ Input: m = 2, n = 2, maxMove = 0, startRow = 0, startColumn = 0

› Output: 0

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

Constraints

1 ≤ m, n ≤ 50
0 ≤ maxMove ≤ 50
0 ≤ startRow < m
0 ≤ startColumn < n

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to use dynamic programming to count paths systematically. Best approach is 2D DP processing each move level iteratively. Time: O(m×n×maxMove), Space: O(m×n)

Common Approaches

✓ 2D Dynamic Programming

⏱️ Time: O(m × n × maxMove) Space: O(m × n)

Use iterative dynamic programming with 2D tables. For each move level, calculate paths from each cell based on previous level.

Memoized Recursion

⏱️ Time: O(m × n × maxMove) Space: O(m × n × maxMove)

Same recursive approach but store results for each (x, y, moves) state to avoid recalculating the same subproblems.

Recursive Brute Force

⏱️ Time: O(4^maxMove) Space: O(maxMove)

For each position, try moving in all 4 directions recursively. Count paths that lead out of bounds within the move limit.

2D Dynamic Programming — Algorithm Steps

Initialize DP table for current moves
For each cell, sum paths from adjacent cells
Handle boundary conditions
Accumulate total boundary exits

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start position has 1 way to reach

Process Move

Calculate next level from current positions

Count Exits

Add boundary crossings to result

Code -

solution.c — C

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

const int MOD = 1000000007;

int solution(int m, int n, int maxMove, int startRow, int startColumn) {
    int** prevDp = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        prevDp[i] = (int*)calloc(n, sizeof(int));
    }
    prevDp[startRow][startColumn] = 1;
    
    long long result = 0;
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    
    for (int move = 0; move < maxMove; move++) {
        int** currDp = (int**)malloc(m * sizeof(int*));
        for (int i = 0; i < m; i++) {
            currDp[i] = (int*)calloc(n, sizeof(int));
        }
        
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (prevDp[i][j] > 0) {
                    for (int d = 0; d < 4; d++) {
                        int ni = i + directions[d][0];
                        int nj = j + directions[d][1];
                        if (ni < 0 || ni >= m || nj < 0 || nj >= n) {
                            result = (result + prevDp[i][j]) % MOD;
                        } else {
                            currDp[ni][nj] = (currDp[ni][nj] + prevDp[i][j]) % MOD;
                        }
                    }
                }
            }
        }
        
        // Free previous DP table
        for (int i = 0; i < m; i++) {
            free(prevDp[i]);
        }
        free(prevDp);
        
        prevDp = currDp;
    }
    
    // Free final DP table
    for (int i = 0; i < m; i++) {
        free(prevDp[i]);
    }
    free(prevDp);
    
    return (int) result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(m × n × maxMove)

Iterate through maxMove levels, each level processes m×n cells

✓ Linear Growth

Space Complexity

O(m × n)

Only need current and previous DP tables, can optimize to O(m×n)

✓ Linear Space

23.0K Views

Medium Frequency

~25 min Avg. Time

892 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

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler