Minimum Number of Visited Cells in a Grid

Minimum Number of Visited Cells in a Grid - Problem

Array Dynamic Programming Stack Breadth-First Search Union Find Heap (Priority Queue) Matrix Monotonic Stack Hard

You are given a m × n integer matrix grid where you start at the top-left corner (0, 0) and need to reach the bottom-right corner (m-1, n-1).

From any cell (i, j), you can make strategic jumps based on the cell's value grid[i][j]:

Right jumps: Move to any cell (i, k) where j < k ≤ grid[i][j] + j
Down jumps: Move to any cell (k, j) where i < k ≤ grid[i][j] + i

Your goal is to find the minimum number of cells you need to visit to reach the destination. If no valid path exists, return -1.

Example: If you're at cell (0, 0) with value 3, you can jump right to columns 1, 2, 3 or down to rows 1, 2, 3 in the same column.

Input & Output

example_1.py — Basic Grid Traversal

$ Input: grid = [[3,4,2,1],[4,2,3,1],[2,1,0,0],[2,4,0,0]]

› Output: 4

💡 Note: Starting from (0,0) with value 3, we can jump to (0,1), (0,2), (0,3), (1,0), (2,0), or (3,0). The optimal path is (0,0) → (0,2) → (3,2) → (3,3) requiring 4 cells to be visited.

example_2.py — Impossible Path

$ Input: grid = [[3,4,2,1],[4,2,1,1],[2,1,1,0],[2,4,0,0]]

› Output: -1

💡 Note: From the starting position, we cannot reach the bottom-right corner due to the 0 values blocking our path. The cell (2,2) has value 1 which only allows movement to (2,3), but (2,3) has value 0 preventing further movement.

example_3.py — Single Cell

$ Input: grid = [[2]]

› Output: 1

💡 Note: The grid has only one cell, so we're already at the destination. Only 1 cell needs to be visited.

Visualization

Tap to expand

Understanding the Visualization

Start Position

Begin at top-left corner (0,0) with step count 1

Explore Jumps

From each cell, calculate all valid right and down jumps based on cell value

BFS Traversal

Use BFS to explore cells level by level, ensuring minimum path length

Destination Check

Return step count when bottom-right corner is reached, or -1 if impossible

Key Takeaway

🎯 Key Insight: BFS guarantees finding the minimum path length by exploring all cells at distance k before exploring cells at distance k+1, making it the optimal approach for this shortest path problem.

Time & Space Complexity

Time Complexity

⏱️

O(m * n * (m + n))

Each cell can be visited multiple times, and from each cell we explore up to m+n jumps

✓ Linear Growth

Space Complexity

O(m * n)

Queue and visited set can store up to all cells in the grid

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 10⁵
1 ≤ m * n ≤ 10⁵
0 ≤ grid[i][j] < m * n
grid[m - 1][n - 1] == 0

Asked in

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

This is a shortest path problem that can be solved using BFS (Breadth-First Search) which naturally finds the minimum number of steps. From each cell, we can make strategic jumps right or down based on the cell's value. For optimal performance on large grids, consider using optimized BFS with segment trees or Dijkstra's algorithm with priority queues to efficiently handle range updates and queries.

Common Approaches

Approach	Time	Space	Notes
✓ BFS (Breadth-First Search)	O(m * n * (m + n))	O(m * n)	Use BFS to explore all paths level by level, guaranteeing minimum steps

BFS (Breadth-First Search) — Algorithm Steps

Initialize queue with starting position (0,0) and step count 1
For each cell, explore all valid jumps (right and down)
Track visited cells to avoid cycles
Return step count when destination is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start at (0,0) with step count 1

Level 1

Explore all cells reachable in 1 jump

Level 2

Explore all cells reachable in 2 jumps

Found Goal

Return when destination is reached

Code -

solution.c — C

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

#define MAX_SIZE 1000
#define MAX_QUEUE 100000

typedef struct {
    int i, j, steps;
} Cell;

int minimumVisitedCells(int grid[][MAX_SIZE], int m, int n) {
    if (m == 1 && n == 1) return 1;
    
    bool visited[MAX_SIZE][MAX_SIZE] = {false};
    Cell queue[MAX_QUEUE];
    int front = 0, rear = 0;
    
    queue[rear++] = (Cell){0, 0, 1};
    
    while (front < rear) {
        Cell curr = queue[front++];
        
        if (visited[curr.i][curr.j]) continue;
        visited[curr.i][curr.j] = true;
        
        // Right moves
        int maxRight = curr.j + grid[curr.i][curr.j];
        if (maxRight >= n) maxRight = n - 1;
        for (int k = curr.j + 1; k <= maxRight; k++) {
            if (k == n - 1 && curr.i == m - 1) return curr.steps + 1;
            if (!visited[curr.i][k]) {
                queue[rear++] = (Cell){curr.i, k, curr.steps + 1};
            }
        }
        
        // Down moves
        int maxDown = curr.i + grid[curr.i][curr.j];
        if (maxDown >= m) maxDown = m - 1;
        for (int k = curr.i + 1; k <= maxDown; k++) {
            if (k == m - 1 && curr.j == n - 1) return curr.steps + 1;
            if (!visited[k][curr.j]) {
                queue[rear++] = (Cell){k, curr.j, curr.steps + 1};
            }
        }
    }
    
    return -1;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * n * (m + n))

Each cell can be visited multiple times, and from each cell we explore up to m+n jumps

✓ Linear Growth

Space Complexity

O(m * n)

Queue and visited set can store up to all cells in the grid

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 10⁵
1 ≤ m * n ≤ 10⁵
0 ≤ grid[i][j] < m * n
grid[m - 1][n - 1] == 0

67.3K Views

Medium-High Frequency

~25 min Avg. Time

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

BFS (Breadth-First Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler