Minimum Time Takes to Reach Destination Without Drowning - Problem

You are given an n * m 0-indexed grid of strings called land. Right now, you are standing at the cell that contains "S", and you want to get to the cell containing "D".

There are three other types of cells in this land:

".": These cells are empty.
"X": These cells are stone.
"*": These cells are flooded.

At each second, you can move to a cell that shares a side with your current cell (if it exists). Also, at each second, every empty cell that shares a side with a flooded cell becomes flooded as well.

There are two problems ahead of your journey:

You can't step on stone cells.
You can't step on flooded cells since you will drown (also, you can't step on a cell that will be flooded at the same time as you step on it).

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

Note that the destination will never be flooded.

Input & Output

Example 1 — Basic Escape Path

$ Input: land = [["S",".","D"],[".","X","."],[".","*","."]]

› Output: 3

💡 Note: Start at S, move right to (0,1), then down to (1,2), then up to (0,2) to reach D. Takes 3 seconds total, avoiding the flood spreading from * and the stone X.

Example 2 — No Escape Possible

$ Input: land = [["S","*"],["*","D"]]

› Output: -1

💡 Note: The starting position S is immediately surrounded by flood sources *. There's no safe path to reach destination D.

Example 3 — Direct Path Available

$ Input: land = [["S",".","D"],[".",".","."],["*",".","."]]

› Output: 2

💡 Note: Simple path: S → right to (0,1) → right to (0,2) reaching D. Takes 2 seconds, faster than the flood can reach the path.

Constraints

1 ≤ n, m ≤ 300
land[i][j] ∈ {"S", "D", ".", "X", "*"}
There is exactly one "S" and one "D"
The destination "D" will never be flooded

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is to use multi-source BFS to precompute flood spread times, then find the shortest path that avoids flooded cells. The optimal approach uses two-pass BFS: first simulate flood propagation, then find shortest safe path. Time: O(n×m), Space: O(n×m)

Common Approaches

✓ Multi-Source BFS (Optimal)

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

First, use multi-source BFS from all flood sources to precompute when each cell gets flooded. Then use regular BFS to find shortest path, avoiding cells that are flooded at arrival time.

Naive DFS with Flood Simulation

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

For each possible move, recursively explore all paths while simulating the flood spread at every time step. Check if each cell is safe before moving.

Multi-Source BFS (Optimal) — Algorithm Steps

Find all flood sources and start/end positions
Use multi-source BFS to compute flood time for each cell
Use BFS from start to find shortest path
For each cell, check if we can reach it before it floods

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Sources

Locate start, destination, and all flood sources

Flood BFS

Multi-source BFS to compute when each cell floods

Path BFS

BFS from start to destination avoiding flooded cells

Return Time

Return shortest time or -1 if impossible

Code -

solution.c — C

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

#define MAX_SIZE 300
#define MAX_QUEUE 100000
#define INF 999999999

typedef struct {
    int r, c, time;
} State;

typedef struct {
    int r, c;
} Pos;

int n, m;
char land[MAX_SIZE][MAX_SIZE][2];
int flood_time[MAX_SIZE][MAX_SIZE];
Pos start, dest;
Pos flood_sources[MAX_SIZE * MAX_SIZE];
int flood_sources_count = 0;
int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

int solution() {
    // Find start, destination, and flood sources
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (strcmp(land[i][j], "S") == 0) {
                start.r = i;
                start.c = j;
            } else if (strcmp(land[i][j], "D") == 0) {
                dest.r = i;
                dest.c = j;
            } else if (strcmp(land[i][j], "*") == 0) {
                flood_sources[flood_sources_count].r = i;
                flood_sources[flood_sources_count].c = j;
                flood_sources_count++;
            }
        }
    }
    
    // Multi-source BFS to find when each cell gets flooded
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            flood_time[i][j] = INF;
        }
    }
    
    State *queue = malloc(MAX_QUEUE * sizeof(State));
    int front = 0, rear = 0;
    
    // Initialize flood sources
    for (int i = 0; i < flood_sources_count; i++) {
        int r = flood_sources[i].r;
        int c = flood_sources[i].c;
        flood_time[r][c] = 0;
        queue[rear].r = r;
        queue[rear].c = c;
        queue[rear].time = 0;
        rear++;
    }
    
    // BFS to spread flood
    while (front < rear) {
        State curr = queue[front];
        front++;
        int r = curr.r;
        int c = curr.c;
        int time = curr.time;
        
        for (int d = 0; d < 4; d++) {
            int dr = directions[d][0];
            int dc = directions[d][1];
            int nr = r + dr;
            int nc = c + dc;
            if (nr >= 0 && nr < n && nc >= 0 && nc < m &&
                strcmp(land[nr][nc], "X") != 0 && strcmp(land[nr][nc], "D") != 0 &&
                flood_time[nr][nc] > time + 1) {
                flood_time[nr][nc] = time + 1;
                queue[rear].r = nr;
                queue[rear].c = nc;
                queue[rear].time = time + 1;
                rear++;
            }
        }
    }
    
    // BFS to find shortest path from start to destination
    if (flood_time[start.r][start.c] == 0) {
        free(queue);
        return -1;  // Start position is flooded
    }
    
    State *path_queue = malloc(MAX_QUEUE * sizeof(State));
    int path_front = 0, path_rear = 0;
    path_queue[path_rear].r = start.r;
    path_queue[path_rear].c = start.c;
    path_queue[path_rear].time = 0;
    path_rear++;
    
    int visited[MAX_SIZE][MAX_SIZE];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            visited[i][j] = 0;
        }
    }
    visited[start.r][start.c] = 1;
    
    while (path_front < path_rear) {
        State curr = path_queue[path_front];
        path_front++;
        int r = curr.r;
        int c = curr.c;
        int time = curr.time;
        
        if (r == dest.r && c == dest.c) {
            free(queue);
            free(path_queue);
            return time;
        }
        
        for (int d = 0; d < 4; d++) {
            int dr = directions[d][0];
            int dc = directions[d][1];
            int nr = r + dr;
            int nc = c + dc;
            if (nr >= 0 && nr < n && nc >= 0 && nc < m &&
                visited[nr][nc] == 0 &&
                strcmp(land[nr][nc], "X") != 0 &&
                (strcmp(land[nr][nc], "D") == 0 || time + 1 < flood_time[nr][nc])) {
                visited[nr][nc] = 1;
                path_queue[path_rear].r = nr;
                path_queue[path_rear].c = nc;
                path_queue[path_rear].time = time + 1;
                path_rear++;
            }
        }
    }
    
    free(queue);
    free(path_queue);
    return -1;
}

void parseJSON(char* line) {
    char* p = strstr(line, "[");
    if (!p) return;
    
    n = 0;
    char* row_start = p;
    while ((row_start = strchr(row_start, '[')) != NULL) {
        if (row_start == p) {
            row_start++;
            continue;
        }
        
        m = 0;
        char* cell_start = row_start + 1;
        while (*cell_start && *cell_start != ']') {
            if (*cell_start == '"') {
                cell_start++;  // Skip opening quote
                char* cell_end = cell_start;
                int cell_len = 0;
                while (*cell_end && *cell_end != '"') {
                    land[n][m][cell_len++] = *cell_end;
                    cell_end++;
                }
                land[n][m][cell_len] = '\0';
                m++;
                cell_start = cell_end + 1;
            } else {
                cell_start++;
            }
        }
        n++;
        row_start = cell_start + 1;
    }
}

int main() {
    char line[1000000];
    if (fgets(line, sizeof(line), stdin)) {
        line[strcspn(line, "\n")] = '\0';
        parseJSON(line);
    }
    
    printf("%d\n", solution());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

Two BFS traversals, each visiting every cell at most once

✓ Linear Growth

Space Complexity

O(n×m)

Queue for BFS and 2D array to store flood times

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~35 min Avg. Time

856 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

Minimum Time Takes to Reach Destination Without Drowning - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Multi-Source BFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler