Find the Safest Path in a Grid

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,1,0],[0,0,0]]

› Output: 2

💡 Note: With one thief at the center (1,1), the optimal path (0,0) → (0,1) → (0,2) → (1,2) → (2,2) maintains minimum distance 2 from the thief.

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

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

✓ Optimized

⏱️ Time: N/A Space: N/A

Binary Search + BFS (Optimal)

⏱️ Time: O(n² log n) Space: O(n²)

First compute distance from each cell to nearest thief using multi-source BFS. Then binary search on the safeness factor - for each candidate answer, use BFS to check if a path exists where every cell has at least that distance to thieves.

Brute Force (DFS All Paths)

⏱️ Time: O(4^(n²)) Space: O(n²)

Generate all possible paths from (0,0) to (n-1,n-1) using DFS, calculate the safeness factor for each path by finding minimum distance to any thief, then return the maximum safeness factor found.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

52.4K 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