Number of Ways to Reach Destination in the Grid

Number of Ways to Reach Destination in the Grid - Problem

Imagine you're navigating a grid-based board game where you can only move in straight lines! You start at a source position and need to reach a destination in exactly k moves.

The Challenge: Given an n × m grid (1-indexed), a starting position source [x, y], and a destination dest [x, y], find the number of ways to reach the destination in exactly k steps.

Movement Rules:

You can move from cell [x1, y1] to [x2, y2] if either x1 == x2 (same row) or y1 == y2 (same column)
You cannot stay in the same cell (no self-loops)
Each move counts as exactly 1 step

Goal: Return the total number of distinct paths of length k from source to destination, modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Grid Navigation

$ Input: n = 2, m = 3, k = 3, source = [1, 1], dest = [2, 3]

› Output: 4

💡 Note: There are 4 different ways to reach destination [2,3] from source [1,1] in exactly 3 steps. Some example paths: [1,1] → [1,2] → [2,2] → [2,3], [1,1] → [1,3] → [2,3] → [2,1] → [2,3], etc.

example_2.py — Same Position

$ Input: n = 3, m = 3, k = 2, source = [1, 1], dest = [1, 1]

› Output: 16

💡 Note: To return to the same position in exactly 2 steps, we can move to any of the 4 adjacent cells (2 in same row + 2 in same column), then return. Each of the 4 first moves has 4 possible return moves, giving 4×4 = 16 total paths.

example_3.py — Impossible Case

$ Input: n = 2, m = 2, k = 1, source = [1, 1], dest = [2, 2]

› Output: 0

💡 Note: From [1,1], we can only move to [1,2] or [2,1] in one step (same row or column). We cannot reach [2,2] directly in 1 step since it requires changing both row and column.

Constraints

1 ≤ n, m ≤ 1000
0 ≤ k ≤ 1000
1 ≤ source[0], dest[0] ≤ n
1 ≤ source[1], dest[1] ≤ m
Grid coordinates are 1-indexed

Visualization

Tap to expand

Understanding the Visualization

Valid Moves

From any position, rook can move to any cell in same row or column

Path Counting

Each sequence of k moves represents a unique path

Memoization

Cache results for (position, remaining_steps) to avoid recomputation

Final Count

Sum all valid k-step paths from source to destination

Key Takeaway

🎯 Key Insight: Transform the grid navigation into a state transition problem where each (position, steps_remaining) represents a unique subproblem that can be memoized for optimal efficiency.

Asked in

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

This grid path counting problem is best solved using dynamic programming with memoization. The key insight is that we can model valid moves (same row or column) as state transitions and cache results for repeated subproblems. The optimal solution runs in O(n × m × k) time and handles all edge cases efficiently, making it suitable for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(n * m * k)	O(n * m * k)	Use memoization to cache results of subproblems and avoid recomputation
Recursive Exploration (Brute Force)	O((n+m)^k)	O(k)	Recursively try all possible k-step paths from source to destination

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Create a memoization table indexed by (x, y, steps)
Use the same recursive logic as brute force
Before computing, check if result exists in memo table
After computing, store result in memo table
Return memoized result for future identical subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

First Call

Compute result for state (x,y,k) and store in memo

Cache Hit

When same state appears again, return cached result

Subproblem Overlap

Many paths lead to same intermediate states

Efficiency Gain

Each unique state computed only once

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_STATES 100000

typedef struct {
    int x, y, steps;
    int ways;
} MemoEntry;

MemoEntry memo[MAX_STATES];
int memoSize = 0;

int findMemo(int x, int y, int steps) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].x == x && memo[i].y == y && memo[i].steps == steps) {
            return memo[i].ways;
        }
    }
    return -1;
}

void addMemo(int x, int y, int steps, int ways) {
    if (memoSize < MAX_STATES) {
        memo[memoSize].x = x;
        memo[memoSize].y = y;
        memo[memoSize].steps = steps;
        memo[memoSize].ways = ways;
        memoSize++;
    }
}

int dfs(int x, int y, int steps, int n, int m, int* dest) {
    if (steps == 0) {
        return (x == dest[0] && y == dest[1]) ? 1 : 0;
    }
    
    int cached = findMemo(x, y, steps);
    if (cached != -1) {
        return cached;
    }
    
    long long ways = 0;
    // Move in same row
    for (int newY = 1; newY <= m; newY++) {
        if (newY != y) {
            ways = (ways + dfs(x, newY, steps - 1, n, m, dest)) % MOD;
        }
    }
    
    // Move in same column
    for (int newX = 1; newX <= n; newX++) {
        if (newX != x) {
            ways = (ways + dfs(newX, y, steps - 1, n, m, dest)) % MOD;
        }
    }
    
    int result = (int) ways;
    addMemo(x, y, steps, result);
    return result;
}

int numberOfWays(int n, int m, int k, int* source, int* dest) {
    memoSize = 0;
    return dfs(source[0], source[1], k, n, m, dest);
}

int main() {
    printf("%d\n", 0); // Placeholder
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * k)

At most n*m*k unique subproblems, each solved once

✓ Linear Growth

Space Complexity

O(n * m * k)

Memoization table stores results for all states plus recursion stack

⚡ Linearithmic Space

43.2K Views

Medium-High Frequency

~25 min Avg. Time

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