Sequential Grid Path Cover - Practice Coding Problems

Sequential Grid Path Cover - Problem

🗺️ Sequential Grid Path Cover

Imagine you're exploring a treasure map represented as a 2D grid of size m × n. The grid contains k special treasure cells numbered from 1 to k, with all other cells marked as 0.

Your mission is to find a path that:

Visits every single cell in the grid exactly once (no cell left behind!)
Collects treasures in order - you must visit cells containing values 1, 2, 3, ..., k in that exact sequence

You can start at any cell and move to adjacent cells (up, down, left, right). Return the complete path as a 2D array where each element [x, y] represents the coordinates of the i-th cell visited.

Challenge: If multiple valid paths exist, return any one. If no path exists, return an empty array.

Input & Output

example_1.py — Simple 2x3 Grid

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

› Output: [[0,0], [0,1], [1,1], [1,2], [0,2], [1,0]]

💡 Note: Start at (0,0) with value 1, move to collect 2 at (1,1), then 3 at (0,2), while visiting all cells exactly once

example_2.py — Single Row

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

› Output: [[0,0], [0,1], [0,2]]

💡 Note: Simple path from left to right collecting numbered cells in sequence

example_3.py — Impossible Case

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

› Output: []

💡 Note: No valid path exists - cannot visit all cells while collecting 1,2,3 in order from these positions

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 4
0 ≤ grid[i][j] ≤ m * n
Each value from 1 to k appears exactly once
k ≤ m * n

Visualization

Tap to expand

Understanding the Visualization

Map Analysis

Identify positions of numbered cells (treasures) and plan route

Path Exploration

Try different starting positions and use backtracking to find valid paths

Constraint Validation

Ensure numbered cells are visited in correct order (1, 2, 3, ...)

Complete Coverage

Verify all cells are visited exactly once

Key Takeaway

🎯 Key Insight: Break the problem into phases - reach each numbered cell in order while ensuring complete grid coverage through backtracking exploration.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

This problem requires backtracking with constraint checking. The key insight is to ensure numbered cells are visited in sequential order while covering every cell exactly once. Use DFS with pruning to explore all possible paths efficiently, backtracking when constraints are violated.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Backtracking	O(4^(m*n))	O(m*n)	Try all possible paths using recursive backtracking

Brute Force Backtracking — Algorithm Steps

Start from each possible cell in the grid
Use DFS to explore all possible paths
Track visited cells and current position in sequence (1 to k)
Ensure numbered cells are visited in correct order
Backtrack when path becomes invalid
Return first valid complete path found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Choose a starting cell and begin path exploration

Explore Neighbors

Try each valid adjacent cell as next move

Check Constraints

Verify numbered cells are visited in order

Backtrack

If path becomes invalid, backtrack and try different route

Code -

solution.c — C

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

#define MAX_SIZE 10

int m, n, k;
int grid[MAX_SIZE][MAX_SIZE];
int numberedCells[MAX_SIZE][2];
int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int result[MAX_SIZE * MAX_SIZE][2];

bool backtrack(int path[][2], bool visited[][MAX_SIZE], int pathLen, int currentNum) {
    if (pathLen == m * n) {
        for (int i = 0; i < pathLen; i++) {
            result[i][0] = path[i][0];
            result[i][1] = path[i][1];
        }
        return true;
    }
    
    int x = path[pathLen - 1][0];
    int y = path[pathLen - 1][1];
    
    for (int d = 0; d < 4; d++) {
        int nx = x + directions[d][0];
        int ny = y + directions[d][1];
        
        if (nx >= 0 && nx < m && ny >= 0 && ny < n && !visited[nx][ny]) {
            bool canMove = false;
            int nextNum = currentNum;
            
            if (currentNum <= k) {
                if (nx == numberedCells[currentNum][0] && ny == numberedCells[currentNum][1]) {
                    canMove = true;
                    nextNum = currentNum + 1;
                } else if (grid[nx][ny] == 0) {
                    canMove = true;
                }
            } else {
                canMove = true;
            }
            
            if (canMove) {
                visited[nx][ny] = true;
                path[pathLen][0] = nx;
                path[pathLen][1] = ny;
                
                if (backtrack(path, visited, pathLen + 1, nextNum)) {
                    return true;
                }
                
                visited[nx][ny] = false;
            }
        }
    }
    
    return false;
}

void gridPathCover() {
    // Find numbered cells
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] > 0) {
                numberedCells[grid[i][j]][0] = i;
                numberedCells[grid[i][j]][1] = j;
                if (grid[i][j] > k) k = grid[i][j];
            }
        }
    }
    
    // Try starting from each cell
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int path[MAX_SIZE * MAX_SIZE][2];
            bool visited[MAX_SIZE][MAX_SIZE] = {false};
            
            path[0][0] = i;
            path[0][1] = j;
            visited[i][j] = true;
            
            int startNum = (grid[i][j] == 1) ? 2 : (grid[i][j] == 0 ? 1 : grid[i][j] + 1);
            
            if (backtrack(path, visited, 1, startNum)) {
                // Print result
                for (int idx = 0; idx < m * n; idx++) {
                    printf("[%d, %d]\n", result[idx][0], result[idx][1]);
                }
                return;
            }
        }
    }
    
    printf("[]\n");
}

int main() {
    // Parse input and call solution
    scanf("%d %d", &m, &n);
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &grid[i][j]);
        }
    }
    
    gridPathCover();
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(m*n))

For each cell, we have up to 4 directions to explore, and we need to visit m*n cells

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack depth and visited array storage

⚡ Linearithmic Space

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

🗺️ Sequential Grid Path Cover

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler