Find a Safe Walk Through a Grid

Find a Safe Walk Through a Grid - Problem

Array Breadth-First Search Graph Heap (Priority Queue) Matrix Shortest Path Medium

Navigate Through a Dangerous Grid

You are an adventurer exploring a treacherous m × n grid where some cells are unsafe traps. Starting at the top-left corner (0, 0) with a given health value, your goal is to reach the bottom-right corner (m-1, n-1) while staying alive.

Grid Rules:
• Move only to adjacent cells (up, down, left, right)
• Safe cells (grid[i][j] = 0) don't affect your health
• Unsafe cells (grid[i][j] = 1) reduce your health by 1
• You must maintain positive health throughout your journey

Return true if you can reach the destination with health ≥ 1, false otherwise.

Think of it as finding the safest path through a minefield while managing your limited health points!

Input & Output

basic_path.py — Basic Safe Path

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

› Output: true

💡 Note: Starting with health=1, we can take path (0,0)→(1,0)→(2,0)→(2,1)→(2,2)→(2,3)→(2,4). We encounter 0 unsafe cells initially, so we never lose health below 1.

insufficient_health.py — Insufficient Health

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

› Output: false

💡 Note: With health=3, every possible path to reach (3,5) requires going through more than 3 unsafe cells, which would reduce health to 0 or below.

minimal_health.py — Edge Case

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

› Output: true

💡 Note: Starting with health=5, optimal path is (0,0)→(0,1)→(0,2)→(1,2)→(2,2). We lose 4 health total (1+1+1+1), ending with health=1 at destination.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 50
1 ≤ health ≤ m + n + 1
grid[i][j] is either 0 or 1
You must maintain positive health throughout the journey

Visualization

Tap to expand

Asked in

G Google 28 a Amazon 22 f Meta 18 ⊞ Microsoft 15 Apple 12

The optimal solution uses Dijkstra's algorithm with a priority queue to always explore paths with maximum remaining health first. This ensures we find the safest route efficiently in O(m*n*health * log(m*n*health)) time, avoiding unnecessary exploration of dangerous paths.

Common Approaches

✓ BFS Path Exploration

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

Use breadth-first search to explore paths level by level. Unlike DFS, BFS explores all positions at distance k before moving to distance k+1. We track each state as (row, col, health) and use a queue to process states.

DFS Backtracking (Brute Force)

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

Use depth-first search to explore every possible path from start to destination. For each cell, try all four directions recursively while tracking current health. This approach guarantees finding a solution if one exists but explores many unnecessary paths.

Dijkstra's Algorithm (Optimal)

⏱️ Time: O(m*n*health * log(m*n*health)) Space: O(m*n*health)

This is the optimal approach using Dijkstra's algorithm. Instead of exploring paths randomly, we use a priority queue to always process the state with maximum health first. This ensures we find the safest path efficiently and avoid exploring unnecessary dangerous paths.

BFS Path Exploration — Algorithm Steps

Initialize queue with starting position and health
For each state, try all 4 directions
Add new valid states to queue
Mark visited states to avoid cycles
Return true if we reach destination with health > 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with (0,0) and initial health in queue

Process Level

Process all states at current distance

Add Next Level

Add all valid next states to queue

Continue

Repeat until destination found or queue empty

Code -

solution.c — C

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

typedef struct {
    int row, col, health;
} State;

typedef struct {
    State* data;
    int front, rear, size, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (State*)malloc(capacity * sizeof(State));
    q->front = q->rear = q->size = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, State s) {
    q->data[q->rear] = s;
    q->rear = (q->rear + 1) % q->capacity;
    q->size++;
}

State dequeue(Queue* q) {
    State s = q->data[q->front];
    q->front = (q->front + 1) % q->capacity;
    q->size--;
    return s;
}

bool findSafeWalk(int** grid, int gridSize, int* gridColSize, int health) {
    int m = gridSize, n = gridColSize[0];
    
    Queue* queue = createQueue(10000);
    bool visited[100][100][200] = {false}; // Assuming constraints
    
    int startHealth = health - grid[0][0];
    if (startHealth <= 0) return false;
    
    enqueue(queue, (State){0, 0, startHealth});
    visited[0][0][startHealth] = true;
    
    int directions[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    
    while (queue->size > 0) {
        State curr = dequeue(queue);
        
        if (curr.row == m-1 && curr.col == n-1) return true;
        
        for (int i = 0; i < 4; i++) {
            int newRow = curr.row + directions[i][0];
            int newCol = curr.col + directions[i][1];
            
            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n) {
                int newHealth = curr.health - grid[newRow][newCol];
                
                if (newHealth > 0 && newHealth < 200 && !visited[newRow][newCol][newHealth]) {
                    visited[newRow][newCol][newHealth] = true;
                    enqueue(queue, (State){newRow, newCol, newHealth});
                }
            }
        }
    }
    
    free(queue->data);
    free(queue);
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(m*n))

In worst case, we still explore exponential number of states

✓ Linear Growth

Space Complexity

O(m*n*health)

Queue can contain up to m*n*health states

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

847 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

BFS Path Exploration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler