Find the Safest Path in a Grid - Practice Coding Problems

Find the Safest Path in a Grid - Problem

Array Binary Search Breadth-First Search Union Find Heap (Priority Queue) Matrix Medium

You're trapped in a dangerous n × n grid filled with thieves, and you need to find the safest possible path from the top-left corner (0, 0) to the bottom-right corner (n-1, n-1)!

The grid contains:

Thieves at positions where grid[r][c] = 1
Empty cells where grid[r][c] = 0

You can move to any adjacent cell (up, down, left, right) in each step. The safeness factor of any path is defined as the minimum Manhattan distance from any cell in your path to the nearest thief.

Goal: Find the path that maximizes this safeness factor - stay as far away from thieves as possible!

Manhattan distance between cells (a,b) and (x,y) = |a-x| + |b-y|

Input & Output

example_1.py — Basic Grid

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

› Output: 0

💡 Note: All paths from (0,0) to (2,2) must pass through cells adjacent to thieves. The maximum safeness factor is 0 since we can't avoid being adjacent to thieves.

example_2.py — Safe Path Exists

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

› Output: 1

💡 Note: The safest path is (0,0) → (0,1) → (1,1) → (2,1) → (2,2). The minimum distance to any thief along this path is 1.

example_3.py — No Thieves

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

› Output: 4

💡 Note: With no thieves in the grid, we can define the safeness as the maximum possible distance, which would be 4 for a 3x3 grid (from corner to opposite corner).

Constraints

1 ≤ n ≤ 400
grid[i][j] is either 0 or 1
There is at least one thief in the grid
Manhattan distance = |x₁ - x₂| + |y₁ - y₂|
Time limit: 3 seconds

Visualization

Tap to expand

Understanding the Visualization

Map Danger Zones

Calculate how far each room is from the nearest intruder using flood-fill

Define Safety Threshold

Use binary search to find the maximum safe distance we can maintain

Find Safe Route

For each threshold, check if a valid path exists using only sufficiently safe rooms

Optimize Path

The answer is the highest safety threshold for which a path exists

Key Takeaway

🎯 Key Insight: By precomputing distances to all thieves and using binary search, we can efficiently find the maximum safeness factor without exploring every possible path.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses binary search on the answer combined with BFS. First, compute distances from each cell to the nearest thief using multi-source BFS. Then binary search on the safeness factor, checking feasibility by finding if a path exists using only cells with sufficient distance to thieves. Time complexity: O(n² log n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS All Paths)	O(4^(n²))	O(n²)	Try every possible path and calculate safeness factor for each
Binary Search + BFS (Optimal)	O(n² log n)	O(n²)	Binary search on answer combined with BFS to check feasibility

Brute Force (DFS All Paths) — Algorithm Steps

Use DFS to explore all possible paths from start to end
For each complete path, calculate safeness by finding minimum Manhattan distance to any thief
Track the maximum safeness factor encountered
Return the maximum safeness factor

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Exploration

Begin DFS from (0,0) exploring all possible directions

Calculate Path Safety

For each complete path, calculate minimum distance to any thief

Track Maximum

Keep track of the path with maximum safeness factor

Code -

solution.c — C

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

#define MAX_N 100

typedef struct {
    int x, y;
} Point;

Point thieves[MAX_N * MAX_N];
int thief_count = 0;
int n;

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int manhattan_dist(int x1, int y1, int x2, int y2) {
    return abs_val(x1 - x2) + abs_val(y1 - y2);
}

int get_path_safeness(Point* path, int path_len) {
    int min_dist = INT_MAX;
    for (int i = 0; i < path_len; i++) {
        for (int j = 0; j < thief_count; j++) {
            int dist = manhattan_dist(path[i].x, path[i].y, thieves[j].x, thieves[j].y);
            if (dist < min_dist) min_dist = dist;
        }
    }
    return min_dist;
}

int dfs(int x, int y, Point* path, int path_len, int visited[MAX_N][MAX_N]) {
    if (x == n-1 && y == n-1) {
        return get_path_safeness(path, path_len);
    }
    
    int max_safe = 0;
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    for (int i = 0; i < 4; i++) {
        int nx = x + directions[i][0];
        int ny = y + directions[i][1];
        
        if (nx >= 0 && nx < n && ny >= 0 && ny < n && !visited[nx][ny]) {
            visited[nx][ny] = 1;
            path[path_len].x = nx;
            path[path_len].y = ny;
            int safe = dfs(nx, ny, path, path_len + 1, visited);
            if (safe > max_safe) max_safe = safe;
            visited[nx][ny] = 0;
        }
    }
    
    return max_safe;
}

int maximum_safeness_factor(int grid[MAX_N][MAX_N]) {
    thief_count = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) {
                thieves[thief_count].x = i;
                thieves[thief_count].y = j;
                thief_count++;
            }
        }
    }
    
    int visited[MAX_N][MAX_N] = {0};
    Point path[MAX_N * MAX_N];
    path[0].x = 0;
    path[0].y = 0;
    visited[0][0] = 1;
    
    return dfs(0, 0, path, 1, visited);
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(n²))

In worst case, we explore 4^(n²) different paths, and for each path we calculate distances to all thieves

⚠ Quadratic Growth

Space Complexity

O(n²)

Recursion stack can go up to n² deep, plus space to store current path

⚠ Quadratic Space

52.3K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (DFS All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler