Escape the Spreading Fire - Practice Coding Problems

Escape the Spreading Fire - Problem

Escape the Spreading Fire

You find yourself trapped in a burning field represented by a 2D grid, where you must escape from the top-left corner (0,0) to a safehouse at the bottom-right corner while avoiding the spreading flames!

🌱 0 = Grass (safe to walk on)
🔥 1 = Fire (spreads every minute)
🧱 2 = Wall (blocks both you and fire)

The challenge: What's the maximum time you can wait before starting your escape?

Game Rules:
• You can move to adjacent grass cells (up, down, left, right)
• After each of your moves, fire spreads to all adjacent non-wall cells
• You need to reach the safehouse before being caught by fire
• If you can reach safely regardless of wait time, return 10⁹
• If escape is impossible, return -1

Victory Condition: Even if fire reaches the safehouse right after you arrive, you still win! 🎯

Input & Output

example_1.py — Basic Escape

$ Input: grid = [[0,2,0,0,0,0,0],[0,0,0,2,2,1,0],[0,2,0,0,1,2,0],[0,0,2,2,2,0,2],[0,0,0,0,0,0,0]]

› Output: 3

💡 Note: You can wait 3 minutes at the starting position before moving. The fire will spread but you can still find a safe path to the bottom-right corner by going around the walls and avoiding the spreading flames.

example_2.py — Impossible Escape

$ Input: grid = [[0,0,0,0],[0,1,2,0],[0,2,0,0]]

› Output: -1

💡 Note: The fire will spread and block all possible paths to the destination. No matter when you start moving, you cannot reach the safehouse safely.

example_3.py — Unlimited Time

$ Input: grid = [[0,0,0],[2,2,0],[0,0,0]]

› Output: 1000000000

💡 Note: There is no fire in the grid (only walls and grass), so you can wait indefinitely and still reach the safehouse. The walls don't block your optimal path.

Time & Space Complexity

Time Complexity

⏱️

O(T × m × n)

T is the maximum waiting time, m×n for BFS and fire simulation each iteration

✓ Linear Growth

Space Complexity

O(m × n)

Grid storage and BFS queue space

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
2 ≤ m, n ≤ 300
4 ≤ m × n ≤ 2 × 10⁴
grid[i][j] is either 0, 1, or 2
grid[0][0] == grid[m-1][n-1] == 0

Asked in

The optimal solution uses binary search on the waiting time combined with BFS pathfinding. Key insight: if we can escape after waiting X minutes, we can also escape after waiting fewer minutes, creating a monotonic property perfect for binary search. Time complexity: O(m × n × log(m × n)).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(T × m × n)	O(m × n)	Test every possible waiting time by simulating fire spread and pathfinding
Binary Search + BFS (Optimal)	O(m × n × log(m × n))	O(m × n)	Use binary search on waiting time combined with efficient fire simulation and BFS pathfinding

Brute Force Simulation — Algorithm Steps

Start with waiting time = 0
For each waiting time, simulate fire spread
Use BFS to check if escape path exists
Increment waiting time and repeat
Stop when no path exists or reasonable limit reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original grid, test wait time = 0

Fire Spread

Simulate fire spreading for the current wait time

Path Search

Use BFS to find if escape path exists

Increment

If successful, try next wait time; if failed, return previous

Code -

solution.c — C

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

#define MAX_QUEUE 10000

typedef struct {
    int x, y, time;
} Position;

int directions[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
int m, n;

int** spreadFire(int** fireGrid, int gridSize, int* gridColSize, int minutes) {
    int** result = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        result[i] = (int*)malloc(n * sizeof(int));
        memcpy(result[i], fireGrid[i], n * sizeof(int));
    }
    
    Position queue[MAX_QUEUE];
    int front = 0, rear = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (result[i][j] == 1) {
                queue[rear++] = (Position){i, j, 0};
            }
        }
    }
    
    while (front < rear) {
        Position curr = queue[front++];
        if (curr.time >= minutes) continue;
        
        for (int d = 0; d < 4; d++) {
            int nx = curr.x + directions[d][0];
            int ny = curr.y + directions[d][1];
            
            if (nx >= 0 && nx < m && ny >= 0 && ny < n && result[nx][ny] == 0) {
                result[nx][ny] = 1;
                queue[rear++] = (Position){nx, ny, curr.time + 1};
            }
        }
    }
    
    return result;
}

bool canEscape(int** fireGrid, int gridSize, int* gridColSize, int waitTime) {
    int** currentGrid = spreadFire(fireGrid, gridSize, gridColSize, waitTime);
    
    if (currentGrid[0][0] == 1) {
        for (int i = 0; i < m; i++) free(currentGrid[i]);
        free(currentGrid);
        return false;
    }
    
    Position queue[MAX_QUEUE];
    bool visited[100][100] = {false};
    int front = 0, rear = 0;
    
    queue[rear++] = (Position){0, 0, 0};
    visited[0][0] = true;
    
    while (front < rear) {
        Position curr = queue[front++];
        
        if (curr.x == m-1 && curr.y == n-1) {
            for (int i = 0; i < m; i++) free(currentGrid[i]);
            free(currentGrid);
            return true;
        }
        
        for (int d = 0; d < 4; d++) {
            int nx = curr.x + directions[d][0];
            int ny = curr.y + directions[d][1];
            
            if (nx >= 0 && nx < m && ny >= 0 && ny < n && 
                !visited[nx][ny] && currentGrid[nx][ny] != 2) {
                
                int** futureGrid = spreadFire(fireGrid, gridSize, gridColSize, waitTime + curr.time + 1);
                if (futureGrid[nx][ny] != 1) {
                    visited[nx][ny] = true;
                    queue[rear++] = (Position){nx, ny, curr.time + 1};
                }
                
                for (int i = 0; i < m; i++) free(futureGrid[i]);
                free(futureGrid);
            }
        }
    }
    
    for (int i = 0; i < m; i++) free(currentGrid[i]);
    free(currentGrid);
    return false;
}

int maximumMinutes(int** grid, int gridSize, int* gridColSize) {
    m = gridSize;
    n = gridColSize[0];
    
    int maxWait = 0;
    for (int wait = 0; wait < 200; wait++) {
        if (canEscape(grid, gridSize, gridColSize, wait)) {
            maxWait = wait;
        } else {
            break;
        }
    }
    
    if (canEscape(grid, gridSize, gridColSize, 200)) {
        return 1000000000;
    }
    
    return maxWait > 0 || canEscape(grid, gridSize, gridColSize, 0) ? maxWait : -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(T × m × n)

T is the maximum waiting time, m×n for BFS and fire simulation each iteration

✓ Linear Growth

Space Complexity

O(m × n)

Grid storage and BFS queue space

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
2 ≤ m, n ≤ 300
4 ≤ m × n ≤ 2 × 10⁴
grid[i][j] is either 0, 1, or 2
grid[0][0] == grid[m-1][n-1] == 0

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

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler