Minimum Path Cost in a Hidden Grid - Practice Coding Problems

Minimum Path Cost in a Hidden Grid - Problem

Array Depth-First Search Breadth-First Search Graph Heap (Priority Queue) Matrix Interactive Shortest Path Medium

You control a robot in a mysterious hidden grid where each cell has a movement cost and you need to find the minimum cost path to reach a target destination!

This is an interactive problem - you don't know the grid layout, dimensions, starting position, or target location upfront. Instead, you must explore the grid using a GridMaster API:

canMove(direction) - Check if robot can move in direction ('U', 'D', 'L', 'R')
move(direction) - Move robot and return the cost of the destination cell (-1 if blocked)
isTarget() - Check if current cell is the target

Each cell is either empty (with a positive movement cost) or blocked. The starting cell's cost doesn't count - only cells you move into have costs applied.

Goal: Return the minimum total cost to reach the target, or -1 if impossible.

Challenge: You must first explore and map the grid using DFS/BFS, then find the shortest weighted path using Dijkstra's algorithm!

Input & Output

example_1.py — Basic Grid Navigation

$ Input: grid = [[3,1,1,2],[1,2,3,1],[4,2,1,0],[2,3,1,1]] start = (0,0), target = (3,3)

› Output: 6

💡 Note: The robot explores the grid using DFS, mapping all accessible cells and their costs. Then Dijkstra's algorithm finds the minimum cost path: (0,0)→(0,1)→(1,1)→(2,2)→(3,3) with total cost 0+1+2+1+1=5. Note: starting cell cost doesn't count, so actual path cost is 1+2+1+2=6.

example_2.py — Blocked Cells

$ Input: grid = [[2,1,0,3],[1,0,2,1],[4,1,2,1]] start = (0,0), target = (2,3)

› Output: 8

💡 Note: Some cells are blocked (value 0), so the robot must find an alternative path. After DFS exploration, Dijkstra finds the optimal route avoiding blocked cells: (0,0)→(1,0)→(2,0)→(2,1)→(2,2)→(2,3) with minimum total cost of 8.

example_3.py — No Valid Path

$ Input: grid = [[1,0,0],[0,2,0],[0,0,1]] start = (0,0), target = (2,2)

› Output: -1

💡 Note: The target cell is completely surrounded by blocked cells (0s), making it unreachable from the starting position. DFS exploration confirms no path exists, so the function returns -1.

Time & Space Complexity

Time Complexity

⏱️

O((V + E) log V)

DFS exploration O(V + E) plus Dijkstra's algorithm O((V + E) log V) where V is cells and E is connections

⚡ Linearithmic

Space Complexity

O(V)

Store the grid map, priority queue, and distance array

✓ Linear Space

Constraints

1 ≤ m, n ≤ 200 (grid dimensions)
Grid cells contain values 0 (blocked) or 1-1000 (movement cost)
Starting and target cells are guaranteed to be different and unblocked
Robot can only move in 4 directions: up, down, left, right
Interactive constraint: You cannot access grid dimensions or positions directly

Asked in

The optimal solution uses a two-phase approach: First, systematically explore the hidden grid using DFS to map all accessible cells and their costs. Then apply Dijkstra's algorithm with a priority queue to find the true minimum cost path from start to target, properly considering the weighted edges between cells.

Common Approaches

Approach	Time	Space	Notes
✓ DFS Exploration + Dijkstra's Algorithm (Optimal)	O((V + E) log V)	O(V)	Explore grid with DFS, then find minimum cost path using Dijkstra's algorithm
DFS Exploration + Simple BFS	O(V + E)	O(V)	Explore grid with DFS, then use simple BFS ignoring edge weights

DFS Exploration + Dijkstra's Algorithm (Optimal) — Algorithm Steps

Use DFS to explore and map the entire accessible grid
Record each cell's position, cost, and neighboring connections
Identify the target position during exploration
Apply Dijkstra's algorithm using a priority queue
Always expand the lowest-cost unvisited cell first
Return the minimum total cost to reach target

Visualization

Tap to expand

Step-by-Step Walkthrough

DFS Grid Exploration

Systematically explore all reachable cells using DFS

Build Weighted Graph

Create adjacency list with actual movement costs

Initialize Dijkstra

Start with priority queue containing start position

Expand Minimum Cost

Always process the lowest-cost unvisited cell first

Update Distances

Relax edges and update shortest distances to neighbors

Find Optimal Path

Return minimum cost when target is reached

Code -

solution.c — C

// DFS Exploration + Dijkstra's Algorithm (Optimal)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <limits.h>

#define MAX_CELLS 10000
#define MAX_HEAP 10000

typedef struct {
    char key[20];
    int cost;
} GridCell;

typedef struct {
    int cost;
    char pos[20];
} HeapNode;

static GridCell grid[MAX_CELLS];
static int gridSize = 0;
static char targetPos[20] = "";
static HeapNode heap[MAX_HEAP];
static int heapSize = 0;

void heapPush(int cost, const char* pos) {
    int i = heapSize++;
    heap[i].cost = cost;
    strcpy(heap[i].pos, pos);
    
    while (i > 0) {
        int parent = (i - 1) / 2;
        if (heap[parent].cost <= heap[i].cost) break;
        
        HeapNode temp = heap[i];
        heap[i] = heap[parent];
        heap[parent] = temp;
        i = parent;
    }
}

HeapNode heapPop() {
    HeapNode result = heap[0];
    heap[0] = heap[--heapSize];
    
    int i = 0;
    while (2 * i + 1 < heapSize) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int smallest = i;
        
        if (heap[left].cost < heap[smallest].cost) smallest = left;
        if (right < heapSize && heap[right].cost < heap[smallest].cost) smallest = right;
        
        if (smallest == i) break;
        
        HeapNode temp = heap[i];
        heap[i] = heap[smallest];
        heap[smallest] = temp;
        i = smallest;
    }
    
    return result;
}

int findCost(const char* key) {
    for (int i = 0; i < gridSize; i++) {
        if (strcmp(grid[i].key, key) == 0) {
            return grid[i].cost;
        }
    }
    return -1;
}

bool hasKey(const char* key) {
    return findCost(key) != -1;
}

void addToGrid(const char* key, int cost) {
    strcpy(grid[gridSize].key, key);
    grid[gridSize].cost = cost;
    gridSize++;
}

char getOpposite(char dir) {
    switch(dir) {
        case 'R': return 'L';
        case 'L': return 'R';
        case 'U': return 'D';
        case 'D': return 'U';
    }
    return ' ';
}

void dfs(GridMaster* master, int row, int col) {
    if (master->isTarget(master)) {
        sprintf(targetPos, "%d,%d", row, col);
    }
    
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    char dirChars[4] = {'R', 'L', 'D', 'U'};
    
    for (int i = 0; i < 4; i++) {
        int newRow = row + directions[i][0];
        int newCol = col + directions[i][1];
        char key[20];
        sprintf(key, "%d,%d", newRow, newCol);
        
        if (!hasKey(key) && master->canMove(master, dirChars[i])) {
            int cost = master->move(master, dirChars[i]);
            if (cost != -1) {
                addToGrid(key, cost);
                dfs(master, newRow, newCol);
                master->move(master, getOpposite(dirChars[i]));
            }
        }
    }
}

int findShortestPath(GridMaster* master) {
    gridSize = 0;
    heapSize = 0;
    strcpy(targetPos, "");
    
    addToGrid("0,0", 0);
    dfs(master, 0, 0);
    
    if (strlen(targetPos) == 0) return -1;
    
    // Dijkstra's algorithm
    int distances[MAX_CELLS];
    bool visited[MAX_CELLS] = {false};
    
    for (int i = 0; i < gridSize; i++) {
        distances[i] = INT_MAX;
    }
    distances[0] = 0;  // Start position
    
    heapPush(0, "0,0");
    
    while (heapSize > 0) {
        HeapNode current = heapPop();
        
        if (strcmp(current.pos, targetPos) == 0) {
            return current.cost;
        }
        
        int currentIdx = -1;
        for (int i = 0; i < gridSize; i++) {
            if (strcmp(grid[i].key, current.pos) == 0) {
                currentIdx = i;
                break;
            }
        }
        
        if (currentIdx == -1 || visited[currentIdx]) continue;
        visited[currentIdx] = true;
        
        int row, col;
        sscanf(current.pos, "%d,%d", &row, &col);
        
        int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
        for (int i = 0; i < 4; i++) {
            char neighborKey[20];
            sprintf(neighborKey, "%d,%d", row + directions[i][0], col + directions[i][1]);
            
            int neighborCost = findCost(neighborKey);
            if (neighborCost != -1) {
                int newCost = current.cost + neighborCost;
                
                int neighborIdx = -1;
                for (int j = 0; j < gridSize; j++) {
                    if (strcmp(grid[j].key, neighborKey) == 0) {
                        neighborIdx = j;
                        break;
                    }
                }
                
                if (neighborIdx != -1 && !visited[neighborIdx] && newCost < distances[neighborIdx]) {
                    distances[neighborIdx] = newCost;
                    heapPush(newCost, neighborKey);
                }
            }
        }
    }
    
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O((V + E) log V)

DFS exploration O(V + E) plus Dijkstra's algorithm O((V + E) log V) where V is cells and E is connections

⚡ Linearithmic

Space Complexity

O(V)

Store the grid map, priority queue, and distance array

✓ Linear Space

Constraints

1 ≤ m, n ≤ 200 (grid dimensions)
Grid cells contain values 0 (blocked) or 1-1000 (movement cost)
Starting and target cells are guaranteed to be different and unblocked
Robot can only move in 4 directions: up, down, left, right
Interactive constraint: You cannot access grid dimensions or positions directly

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

DFS Exploration + Dijkstra's Algorithm (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler