Shortest Path to Get Food - Practice Coding Problems

Shortest Path to Get Food - Problem

You're trapped in a maze and starving! You need to find the shortest path to reach any food source as quickly as possible.

Given an m × n character matrix representing a grid-based world:

'*' - Your starting location (exactly one exists)
'#' - Food cells (one or more may exist)
'O' - Free walkable space
'X' - Obstacles that block movement

You can move in four directions (north, east, south, west) to adjacent cells, but cannot pass through obstacles.

Goal: Return the minimum number of steps to reach any food cell, or -1 if no path exists.

Example: If you're at position (0,0) marked with '*' and there's food '#' at position (2,2), you need to find the shortest route avoiding any 'X' obstacles.

Input & Output

example_1.py — Basic Path

$ Input: grid = [['*','O','#'],['O','O','X'],['O','X','X']]

› Output: 2

💡 Note: Starting at (0,0), we can reach food at (0,2) in 2 steps: right to (0,1), then right to (0,2).

example_2.py — Multiple Food Sources

$ Input: grid = [['*','O','O','O'],['O','X','O','#'],['O','O','O','#'],['O','#','X','X']]

› Output: 3

💡 Note: Multiple food cells exist. The closest one at (1,3) can be reached in 3 steps, which is shorter than reaching other food cells.

example_3.py — No Path Available

$ Input: grid = [['*','X','X'],['X','X','X'],['X','X','#']]

› Output: -1

💡 Note: Player is completely surrounded by obstacles 'X', making it impossible to reach any food cell.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start BFS from player position '*' with distance 0

Wave 1

Explore all adjacent cells (distance 1) and add valid ones to queue

Wave 2

Process distance 1 cells, explore their neighbors (distance 2)

Continue

Keep expanding waves until food '#' is found or no cells remain

Key Takeaway

🎯 Key Insight: BFS explores positions in order of increasing distance, so the first food cell encountered is guaranteed to be at the shortest possible distance.

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We visit each cell at most once, where m×n is the total number of cells

✓ Linear Growth

Space Complexity

O(m×n)

Queue and visited set can store up to all cells in worst case

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 200
grid[i][j] is '*', '#', 'O', or 'X'
Exactly one '*' cell exists
At least one '#' cell exists

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 19

The optimal approach uses Breadth-First Search (BFS) to explore the grid level by level. BFS naturally finds the shortest path because it visits all cells at distance k before visiting cells at distance k+1. Time complexity is O(m×n) where we visit each cell at most once.

Common Approaches

Approach	Time	Space	Notes
✓ Breadth-First Search (Optimal)	O(m×n)	O(m×n)	Use BFS to find shortest path by exploring level by level
Brute Force (DFS All Paths)	O(4^(m×n))	O(m×n)	Try every possible path from start to each food cell using DFS

Breadth-First Search (Optimal) — Algorithm Steps

Find the starting position '*' in the grid
Initialize a queue with the starting position and distance 0
Use a visited set to avoid revisiting cells
For each position, explore all 4 adjacent directions
If we find a food cell '#', return the current distance
Continue until queue is empty (no path exists) or food is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start BFS

Begin at starting position '*' with distance 0

Explore Level 1

Visit all cells 1 step away from start

Explore Level 2

Visit all cells 2 steps away from start

Find Food

First food cell encountered is at minimum distance

Code -

solution.c — C

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

typedef struct {
    int row, col, steps;
} Position;

typedef struct {
    Position* data;
    int front, rear, size, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = malloc(sizeof(Queue));
    q->data = malloc(capacity * sizeof(Position));
    q->front = q->rear = q->size = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, Position pos) {
    q->data[q->rear] = pos;
    q->rear = (q->rear + 1) % q->capacity;
    q->size++;
}

Position dequeue(Queue* q) {
    Position pos = q->data[q->front];
    q->front = (q->front + 1) % q->capacity;
    q->size--;
    return pos;
}

bool isEmpty(Queue* q) {
    return q->size == 0;
}

int getFood(char** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = gridColSize[0];
    int startRow = -1, startCol = -1;
    
    // Find starting position
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == '*') {
                startRow = i;
                startCol = j;
                break;
            }
        }
        if (startRow != -1) break;
    }
    
    // BFS
    Queue* queue = createQueue(m * n);
    bool** visited = malloc(m * sizeof(bool*));
    for (int i = 0; i < m; i++) {
        visited[i] = calloc(n, sizeof(bool));
    }
    
    enqueue(queue, (Position){startRow, startCol, 0});
    visited[startRow][startCol] = true;
    
    int directions[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    
    while (!isEmpty(queue)) {
        Position current = dequeue(queue);
        
        // Check if current cell is food
        if (grid[current.row][current.col] == '#') {
            // Free memory
            free(queue->data);
            free(queue);
            for (int i = 0; i < m; i++) {
                free(visited[i]);
            }
            free(visited);
            return current.steps;
        }
        
        // Explore all 4 directions
        for (int i = 0; i < 4; i++) {
            int newRow = current.row + directions[i][0];
            int newCol = current.col + directions[i][1];
            
            // Check bounds and validity
            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n &&
                !visited[newRow][newCol] && grid[newRow][newCol] != 'X') {
                
                visited[newRow][newCol] = true;
                enqueue(queue, (Position){newRow, newCol, current.steps + 1});
            }
        }
    }
    
    // Free memory
    free(queue->data);
    free(queue);
    for (int i = 0; i < m; i++) {
        free(visited[i]);
    }
    free(visited);
    
    return -1;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We visit each cell at most once, where m×n is the total number of cells

✓ Linear Growth

Space Complexity

O(m×n)

Queue and visited set can store up to all cells in worst case

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 200
grid[i][j] is '*', '#', 'O', or 'X'
Exactly one '*' cell exists
At least one '#' cell exists

47.2K Views

Medium Frequency

~15 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Breadth-First Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler