Shortest Path to Get Food

Shortest Path to Get Food - Problem

You are starving and want to eat food as quickly as possible. Find the shortest path to arrive at any food cell.

You are given an m x n character matrix grid with these cell types:

'*' is your location (exactly one cell)
'#' is a food cell (may be multiple)
'O' is free space you can travel through
'X' is an obstacle you cannot travel through

You can move to any adjacent cell (north, east, south, west) if it's not an obstacle.

Return the length of the shortest path to reach any food cell. If no path exists, return -1.

Input & Output

Example 1 — Basic Path

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

› Output: 2

💡 Note: Shortest path from '*' at (0,0) to '#' at (0,2): right → right = 2 steps

Example 2 — Blocked Direct Path

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

› Output: 3

💡 Note: Direct path blocked by 'X', must go: down → right → right = 3 steps

Example 3 — No Path

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

› Output: -1

💡 Note: Starting position completely surrounded by obstacles, no path to food

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 200
grid[i][j] is '*', '#', 'O', or 'X'
The grid contains exactly one '*'.

Visualization

Tap to expand

Asked in

F Facebook 15 a Amazon 12 G Google 8

The key insight is that BFS guarantees the shortest path in unweighted grids because it explores cells level by level. Best approach is BFS starting from '*' position. Time: O(m×n), Space: O(m×n)

Common Approaches

✓ Breadth-First Search (Optimal)

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

BFS explores cells level by level, ensuring the first food cell found is reached via the shortest path. Uses a queue to process cells in order of distance from start.

Brute Force DFS

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

Use DFS to explore every possible path from start to each food cell. Track the minimum path length found across all complete paths.

Breadth-First Search (Optimal) — Algorithm Steps

Find starting position '*'
Use BFS with queue to explore level by level
Return distance when first food '#' is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start BFS from '*' position with queue

Explore Level

Process all cells at current distance

Find Food

First '#' found is via shortest path

Code -

solution.c — C

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

#define MAX_SIZE 200
#define MAX_QUEUE 40000

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

static char grid[MAX_SIZE][MAX_SIZE];
static int visited[MAX_SIZE][MAX_SIZE];

int solution(int m, int n) {
    if (m == 0 || n == 0) {
        return -1;
    }
    
    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;
        }
    }
    
    if (startRow == -1) {
        return -1;
    }
    
    // Clear visited array
    memset(visited, 0, sizeof(visited));
    
    // BFS
    State queue[MAX_QUEUE];
    int front = 0, rear = 0;
    
    queue[rear++] = (State){startRow, startCol, 0};
    visited[startRow][startCol] = 1;
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    while (front < rear) {
        State current = queue[front++];
        int row = current.row;
        int col = current.col;
        int steps = current.steps;
        
        // Check if we found food
        if (grid[row][col] == '#') {
            return steps;
        }
        
        // Explore all 4 directions
        for (int i = 0; i < 4; i++) {
            int newRow = row + directions[i][0];
            int newCol = col + directions[i][1];
            
            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n &&
                !visited[newRow][newCol] && grid[newRow][newCol] != 'X') {
                
                visited[newRow][newCol] = 1;
                queue[rear++] = (State){newRow, newCol, steps + 1};
            }
        }
    }
    
    return -1;
}

int main() {
    char line[100000];
    
    if (fgets(line, sizeof(line), stdin) == NULL) {
        printf("-1\n");
        return 0;
    }
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    line[strcspn(line, "\r")] = 0;
    
    // Handle empty array case
    if (strcmp(line, "[]") == 0) {
        printf("-1\n");
        return 0;
    }
    
    int m = 0, n = 0;
    char* p = line;
    
    // Find outer '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse each row
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',' || *p == '\n' || *p == '\r') p++;
        
        if (*p == ']' || *p == '\0') break;
        
        // Found inner '[' - start of a row
        if (*p == '[') {
            p++; // Skip '['
            n = 0;
            
            while (*p && *p != ']') {
                // Skip whitespace and commas
                while (*p == ' ' || *p == ',') p++;
                
                if (*p == ']') break;
                
                // Found opening quote for a character
                if (*p == '"') {
                    p++; // Skip opening quote
                    
                    // Read the character
                    if (*p && *p != '"') {
                        grid[m][n] = *p;
                        n++;
                        p++;
                    }
                    
                    // Skip closing quote
                    if (*p == '"') p++;
                } else {
                    p++;
                }
            }
            
            // Skip closing ']' of inner array
            if (*p == ']') p++;
            m++;
        } else {
            p++;
        }
    }
    
    printf("%d\n", solution(m, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Visits each cell at most once in the grid

✓ Linear Growth

Space Complexity

O(m×n)

Queue can store up to m×n cells in worst case

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Breadth-First Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler