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.

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

Visualization

Tap to expand

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

✓ BFS (Breadth-First Search)

⏱️ Time: O(m * n * (m + n)) Space: O(m * n)

BFS naturally finds the shortest path by exploring all cells reachable in k steps before exploring cells reachable in k+1 steps. This ensures we find the minimum number of visited cells.

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;

static int grid[MAX_SIZE][MAX_SIZE];
static bool visited[MAX_SIZE][MAX_SIZE];
static Cell queue[MAX_QUEUE];

int minimumVisitedCells(int m, int n) {
    if (m == 1 && n == 1) return 1;
    
    // Clear visited array
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            visited[i][j] = false;
        }
    }
    
    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() {
    char line[100000];
    if (fgets(line, sizeof(line), stdin) == NULL) {
        return 1;
    }
    
    int m = 0, n = 0;
    int pos = 0;
    int len = strlen(line);
    
    // Skip initial '['
    while (pos < len && line[pos] != '[') pos++;
    pos++; // Skip '['
    
    // Parse each row
    while (pos < len) {
        // Skip whitespace and commas
        while (pos < len && (line[pos] == ' ' || line[pos] == ',' || line[pos] == '\n')) pos++;
        
        if (pos >= len || line[pos] == ']') break;
        
        if (line[pos] == '[') {
            pos++; // Skip '['
            int col = 0;
            
            // Parse numbers in this row
            while (pos < len && line[pos] != ']') {
                // Skip whitespace and commas
                while (pos < len && (line[pos] == ' ' || line[pos] == ',')) pos++;
                
                if (pos < len && line[pos] != ']') {
                    int num = 0;
                    while (pos < len && line[pos] >= '0' && line[pos] <= '9') {
                        num = num * 10 + (line[pos] - '0');
                        pos++;
                    }
                    grid[m][col++] = num;
                }
            }
            
            if (m == 0) n = col; // Set number of columns from first row
            pos++; // Skip ']'
            m++;
        } else {
            pos++;
        }
    }
    
    int result = minimumVisitedCells(m, n);
    printf("%d\n", result);
    
    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

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

Minimum Number of Visited Cells in a Grid - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS (Breadth-First Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler