Shortest Path in a Hidden Grid

Shortest Path in a Hidden Grid - Problem

Imagine you're controlling a robot in a mysterious maze where you can't see the full layout! 🤖

This is an interactive problem where you must navigate a robot through a hidden grid to reach a target cell. The twist? You have no idea what the grid looks like, where you started, or where the target is!

Your Mission:

Guide the robot from its starting position to the target cell
Find the shortest path possible
Use only the limited API provided by the GridMaster object

Available API Methods:

canMove(direction) - Check if robot can move in direction ('U', 'D', 'L', 'R')
move(direction) - Move robot (ignored if blocked/invalid)
isTarget() - Check if current cell is the target

The grid contains empty cells (passable) and blocked cells (impassable). You need to explore the unknown terrain, map it out, and then find the optimal route!

Return: The minimum distance to the target, or -1 if unreachable.

Input & Output

example_1.py — Basic Grid

$ Input: grid = [[1,2],[-1,1]] Robot starts at (1,0), Target at (0,1)

› Output: 2

💡 Note: The robot starts at position (1,0) and needs to reach target at (0,1). The shortest path is: (1,0) → (1,1) → (0,1), which has length 2.

example_2.py — Blocked Path

$ Input: grid = [[1,1,1,1],[-1,0,0,2],[1,1,1,1]] Robot starts at (1,0), Target at (1,3)

› Output: -1

💡 Note: The robot cannot reach the target because there's a wall of blocked cells (0) separating the starting position from the target. No valid path exists.

example_3.py — Same Position

$ Input: grid = [[2,-1]] Robot starts at (0,1), Target at (0,0)

› Output: 1

💡 Note: The robot starts adjacent to the target. One move to the left reaches the target, so the shortest distance is 1.

Constraints

1 ≤ m, n ≤ 500 (grid dimensions)
The robot can move in 4 directions: up, down, left, right
The starting cell and target cell are guaranteed to be different
Neither starting cell nor target cell is blocked
Interactive problem - you cannot see the grid directly

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 31 f Meta 28 ⊞ Microsoft 19

The optimal solution uses a two-phase approach: first DFS exploration to systematically map the hidden grid and locate the target, then BFS pathfinding to find the shortest distance on the discovered map. This guarantees finding the optimal path in O(m × n) time complexity.

Common Approaches

✓ DFS Exploration + BFS Shortest Path (Optimal)

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

This is the optimal approach that separates the exploration phase from the pathfinding phase. First, we use DFS to systematically explore and map the entire accessible grid while tracking the target location. Then, we use BFS from the starting position to find the shortest path to the target in our discovered map.

Random Walk Exploration

⏱️ Time: O(∞) Space: O(path_length)

The most naive approach would be to randomly move in available directions until we stumble upon the target. This is highly inefficient and doesn't guarantee finding the shortest path, but demonstrates the basic interaction with the GridMaster API.

DFS Exploration + BFS Shortest Path (Optimal) — Algorithm Steps

Use DFS to explore all reachable cells and build a map
Track passable cells, blocked cells, and target location
Return to starting position after exploration
Apply BFS on the mapped grid to find shortest path
Return the minimum distance or -1 if unreachable

Visualization

Tap to expand

Step-by-Step Walkthrough

DFS Exploration

Systematically explore all reachable cells and map the grid

Target Discovery

Record target position when found during exploration

Return to Start

Backtrack to starting position after complete exploration

BFS Pathfinding

Use BFS on mapped grid to find shortest path to target

Code -

solution.c — C

// DFS Exploration + BFS Shortest Path adapted for grid input
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_SIZE 500
#define MAX_QUEUE 250000

typedef struct {
    int row, col, dist;
} QueueItem;

static int grid[MAX_SIZE][MAX_SIZE];
static char visited[MAX_SIZE][MAX_SIZE];
static QueueItem queue[MAX_QUEUE];

int findShortestPath(int rows, int cols) {
    if (rows == 0 || cols == 0) return -1;
    
    int startRow = -1, startCol = -1;
    int targetRow = -1, targetCol = -1;
    
    // Find start and target positions
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (grid[i][j] == -1) {
                startRow = i;
                startCol = j;
            } else if (grid[i][j] == 2) {
                targetRow = i;
                targetCol = j;
            }
        }
    }
    
    if (startRow == -1 || targetRow == -1) return -1;
    
    if (startRow == targetRow && startCol == targetCol) return 0;
    
    // Initialize visited array
    memset(visited, 0, sizeof(visited));
    
    // BFS to find shortest path
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    int front = 0, rear = 0;
    
    queue[rear++] = (QueueItem){startRow, startCol, 0};
    visited[startRow][startCol] = 1;
    
    while (front < rear) {
        QueueItem current = queue[front++];
        
        for (int d = 0; d < 4; d++) {
            int newRow = current.row + directions[d][0];
            int newCol = current.col + directions[d][1];
            
            if (newRow >= 0 && newRow < rows && newCol >= 0 && newCol < cols &&
                !visited[newRow][newCol] && grid[newRow][newCol] != 0) {
                
                if (newRow == targetRow && newCol == targetCol) {
                    return current.dist + 1;
                }
                
                visited[newRow][newCol] = 1;
                queue[rear++] = (QueueItem){newRow, newCol, current.dist + 1};
            }
        }
    }
    
    return -1;
}

int parseGrid(char* input, int* rows, int* cols) {
    if (strcmp(input, "[]") == 0) {
        *rows = 0;
        *cols = 0;
        return 1;
    }
    
    int len = strlen(input);
    if (len < 2) return 0;
    
    // Remove outer brackets
    input[len-1] = '\0';
    input++;
    
    *rows = 0;
    *cols = 0;
    
    char* row_start = input;
    int in_row = 0;
    
    for (int i = 0; input[i]; i++) {
        if (input[i] == '[') {
            in_row = 1;
            row_start = &input[i+1];
        } else if (input[i] == ']') {
            if (in_row) {
                input[i] = '\0';
                int col = 0;
                char* token = strtok(row_start, ",");
                while (token != NULL) {
                    grid[*rows][col++] = (int)strtol(token, NULL, 10);
                    token = strtok(NULL, ",");
                }
                if (*rows == 0) *cols = col;
                (*rows)++;
                in_row = 0;
            }
        }
    }
    
    return 1;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char input[100000];
    if (!fgets(input, sizeof(input), stdin)) {
        printf("-1\n");
        return 0;
    }
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    int rows, cols;
    if (!parseGrid(input, &rows, &cols)) {
        printf("-1\n");
        return 0;
    }
    
    printf("%d\n", findShortestPath(rows, cols));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

DFS explores each cell once O(mn), BFS also visits each cell once O(mn)

✓ Linear Growth

Space Complexity

O(m × n)

Store the grid map and BFS queue/visited set

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

890 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

DFS Exploration + BFS Shortest Path (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler