Minimum Time Takes to Reach Destination Without Drowning

Minimum Time Takes to Reach Destination Without Drowning - Problem

You find yourself trapped on a dangerous island represented by an n × m grid. Your mission is to escape from your starting position 'S' to the safe destination 'D' before the rising flood waters consume the entire island!

The island contains:

'.' - Empty cells you can walk through
'X' - Stone obstacles that block your path
'*' - Flooded areas that spread each second
'S' - Your starting position
'D' - The safe destination (never floods)

Movement Rules:

Each second, you can move to an adjacent cell (up, down, left, right)
Each second, after your move, floods spread to all empty cells adjacent to flooded areas
You cannot step on stones or flooded cells
You cannot step on a cell that will be flooded at the same time you arrive

Return the minimum time in seconds to reach the destination, or -1 if escape is impossible.

Input & Output

example_1.py — Basic Grid

$ Input: grid = [['S','.','.','.','D'],['.','X','X','X','.'],['.','.','.','.','.'],['.','*','.','.','.'],['.','.','.','.','.']]

› Output: 6

💡 Note: One possible path: S → down → down → right → right → up → up → right → D. The flood spreads from (3,1) but we can navigate around it to reach D safely in 6 seconds.

example_2.py — Impossible Case

$ Input: grid = [['S','X','*'],['D','X','.'],['.','.','.']]

› Output: -1

💡 Note: The flood at (0,2) will spread and block all possible paths to reach D from S. The stone barrier at X also limits movement options, making escape impossible.

example_3.py — Quick Escape

$ Input: grid = [['S','.','D'],['.','.','.'],['*','.','.']]

› Output: 2

💡 Note: The shortest path is S → right → right → D, taking exactly 2 seconds. The flood starts at (2,0) but won't reach our path in time to block it.

Constraints

1 ≤ n, m ≤ 1000
Grid contains exactly one 'S' and one 'D'
Grid may contain 0 or more '*' (flood sources)
Grid cells are one of: '.', 'X', 'S', 'D', '*'
Destination 'D' will never be flooded

Asked in

The optimal solution uses BFS with flood time precomputation. First, we compute when each cell gets flooded using BFS from all flood sources. Then, we perform BFS on (position, time) states to find the shortest path, ensuring we never step on a cell that will be flooded at our arrival time. This approach guarantees finding the minimum time in O(n*m*T) complexity.

Common Approaches

Approach	Time	Space	Notes
✓ BFS with State Tracking (Optimal)	O(nmT)	O(nmT)	Use BFS to find shortest path while tracking both position and time state
Recursive DFS with Flood Simulation	O(4^(n*m))	O(n*m)	Try all possible paths using DFS while simulating flood spread at each step

BFS with State Tracking (Optimal) — Algorithm Steps

Precompute flood times for all cells using BFS from flood sources
Use BFS starting from (start_x, start_y, 0) state
For each state, try moving in 4 directions to next time step
Check if destination cell is safe at the arrival time
Return time when destination is first reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Precompute Floods

Use BFS from all flood sources to compute when each cell gets flooded

Initialize BFS

Start BFS from source with state (x, y, time)

Explore States

For each state, try moving to adjacent cells at next time step

Check Safety

Only move to cells that won't be flooded at arrival time

Find Destination

Return time when destination is first reached

Code -

solution.c — C

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

#define MAX_SIZE 1000
#define MAX_QUEUE 100000

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

int n, m;
int start[2], end[2];
char grid[MAX_SIZE][MAX_SIZE];
int floodTime[MAX_SIZE][MAX_SIZE];
int visited[MAX_SIZE][MAX_SIZE][MAX_SIZE]; // x, y, time

int isValid(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m;
}

int minimumTime() {
    // Initialize flood times
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            floodTime[i][j] = -1;
        }
    }
    
    // Find start, end, and initial floods
    State floodQueue[MAX_QUEUE];
    int floodFront = 0, floodRear = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] == 'S') {
                start[0] = i; start[1] = j;
            } else if (grid[i][j] == 'D') {
                end[0] = i; end[1] = j;
            } else if (grid[i][j] == '*') {
                floodTime[i][j] = 0;
                floodQueue[floodRear++] = (State){i, j, 0};
            }
        }
    }
    
    // BFS for flood spread
    int dirs[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    while (floodFront < floodRear) {
        State curr = floodQueue[floodFront++];
        for (int i = 0; i < 4; i++) {
            int nx = curr.x + dirs[i][0];
            int ny = curr.y + dirs[i][1];
            if (isValid(nx, ny) && 
                (grid[nx][ny] == '.' || grid[nx][ny] == 'S') && 
                floodTime[nx][ny] == -1) {
                floodTime[nx][ny] = curr.time + 1;
                floodQueue[floodRear++] = (State){nx, ny, curr.time + 1};
            }
        }
    }
    
    // BFS for shortest path
    State pathQueue[MAX_QUEUE];
    int pathFront = 0, pathRear = 0;
    pathQueue[pathRear++] = (State){start[0], start[1], 0};
    memset(visited, 0, sizeof(visited));
    
    while (pathFront < pathRear) {
        State curr = pathQueue[pathFront++];
        
        if (curr.x == end[0] && curr.y == end[1]) {
            return curr.time;
        }
        
        for (int i = 0; i < 4; i++) {
            int nx = curr.x + dirs[i][0];
            int ny = curr.y + dirs[i][1];
            int newTime = curr.time + 1;
            
            if (isValid(nx, ny) && 
                grid[nx][ny] != 'X' &&
                newTime < MAX_SIZE &&
                !visited[nx][ny][newTime] &&
                (floodTime[nx][ny] == -1 || floodTime[nx][ny] > newTime)) {
                
                visited[nx][ny][newTime] = 1;
                pathQueue[pathRear++] = (State){nx, ny, newTime};
            }
        }
    }
    
    return -1;
}

int main() {
    n = 4; m = 4;
    strcpy(grid[0], "S..D");
    strcpy(grid[1], ".XX.");
    strcpy(grid[2], "....");
    strcpy(grid[3], "*...");
    
    printf("%d\n", minimumTime());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m*T)

BFS explores each cell at most T times, where T is the maximum time needed

✓ Linear Growth

Space Complexity

O(n*m*T)

We need to store visited states and flood times, potentially for each (cell, time) combination

⚡ Linearithmic Space

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