Shortest Path in a Hidden Grid - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Start Exploration

Robot begins DFS exploration from unknown starting position, systematically checking all directions

Map Discovery

As robot explores, it builds a mental map of passable cells, blocked walls, and records target location when found

Complete Mapping

DFS continues until all reachable areas are explored, with robot backtracking to ensure complete coverage

Optimal Pathfinding

With complete map available, BFS finds shortest path from start to target on the discovered grid

Key Takeaway

🎯 Key Insight: In interactive problems with hidden information, separate the information gathering phase (exploration) from the problem-solving phase (pathfinding) for optimal results.

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

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

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

Approach	Time	Space	Notes
✓ Random Walk Exploration	O(∞)	O(path_length)	Randomly explore until target is found, track the path taken
DFS Exploration + BFS Shortest Path (Optimal)	O(m × n)	O(m × n)	Use DFS to map the grid, then BFS to find shortest path to target

Random Walk Exploration — Algorithm Steps

Start from initial position
Randomly choose an available direction using canMove()
Move in that direction and check if target with isTarget()
Keep track of moves made
Repeat until target found or no moves possible

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Robot begins at unknown starting position

Random Movement

Choose random available direction and move

Check Target

After each move, check if target is reached

Continue Until Found

Keep moving randomly until target found or stuck

Code -

solution.c — C

// Random Walk Approach (Not Recommended)
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int findShortestPath(GridMaster* master) {
    if (isTarget(master)) return 0;
    
    srand(time(NULL));
    char directions[] = {'U', 'D', 'L', 'R'};
    int pathLength = 0;
    int x = 0, y = 0;
    
    while (pathLength < 10000) {
        if (isTarget(master)) return pathLength;
        
        char availableDirs[4];
        int count = 0;
        
        for (int i = 0; i < 4; i++) {
            if (canMove(master, directions[i])) {
                availableDirs[count++] = directions[i];
            }
        }
        
        if (count == 0) return -1;
        
        char direction = availableDirs[rand() % count];
        move(master, direction);
        
        switch (direction) {
            case 'U': y++; break;
            case 'D': y--; break;
            case 'L': x--; break;
            case 'R': x++; break;
        }
        pathLength++;
    }
    
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(∞)

Could theoretically run forever without finding target

✓ Linear Growth

Space Complexity

O(path_length)

Only stores the current path being taken

⚡ Linearithmic Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Random Walk Exploration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler