Find a Safe Walk Through a Grid - Practice Coding Problems

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

weighted shortest path problem!• Each unsafe cell has weight = 1• Each safe cell has weight = 0• Find path with minimum total weight• Ensure final health ≥ 1Health: 4 → 4 → 3 → 3 ✅

Understanding the Visualization

Start Journey

Begin at top-left with full health, assess immediate danger

Choose Path Wisely

Use Dijkstra's algorithm to prioritize safer routes with higher health

Navigate Carefully

Move through adjacent rooms, losing health only when stepping on traps

Reach Destination

Arrive at treasure room with at least 1 health point remaining

Key Takeaway

🎯 Key Insight: Transform the problem into finding the minimum-weight path where unsafe cells have weight 1 and safe cells have weight 0. Dijkstra's algorithm efficiently finds this optimal path while ensuring we maintain positive health throughout the journey!

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

Approach	Time	Space	Notes
✓ Dijkstra's Algorithm (Optimal)	O(mnhealth * log(mnhealth))	O(mnhealth)	Use priority queue to always explore the path with maximum remaining health first
BFS Path Exploration	O(4^(m*n))	O(mnhealth)	Use BFS to explore all paths level by level
DFS Backtracking (Brute Force)	O(4^(m*n))	O(m*n)	Explore all possible paths using recursive DFS

Dijkstra's Algorithm (Optimal) — Algorithm Steps

Initialize priority queue with starting position and health
Use max-heap to prioritize states with higher health
For each state, explore all 4 directions
Skip states that have been visited with better health
Return true when destination is reached with positive health

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Priority Queue

Start with max-heap prioritizing higher health

Process Best State

Always process state with maximum health first

Add Neighbors

Add all valid neighbors to priority queue

Optimal Path

Find destination with maximum health preserved

Code -

solution.c — C

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

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

typedef struct {
    State* data;
    int size, capacity;
} PriorityQueue;

PriorityQueue* createPQ(int capacity) {
    PriorityQueue* pq = (PriorityQueue*)malloc(sizeof(PriorityQueue));
    pq->data = (State*)malloc(capacity * sizeof(State));
    pq->size = 0;
    pq->capacity = capacity;
    return pq;
}

void heapifyUp(PriorityQueue* pq, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (pq->data[parent].health >= pq->data[idx].health) break;
        State temp = pq->data[parent];
        pq->data[parent] = pq->data[idx];
        pq->data[idx] = temp;
        idx = parent;
    }
}

void heapifyDown(PriorityQueue* pq, int idx) {
    while (2 * idx + 1 < pq->size) {
        int bigger = 2 * idx + 1;
        if (2 * idx + 2 < pq->size && pq->data[2 * idx + 2].health > pq->data[bigger].health) {
            bigger = 2 * idx + 2;
        }
        if (pq->data[idx].health >= pq->data[bigger].health) break;
        State temp = pq->data[idx];
        pq->data[idx] = pq->data[bigger];
        pq->data[bigger] = temp;
        idx = bigger;
    }
}

void push(PriorityQueue* pq, State s) {
    pq->data[pq->size] = s;
    heapifyUp(pq, pq->size);
    pq->size++;
}

State pop(PriorityQueue* pq) {
    State top = pq->data[0];
    pq->data[0] = pq->data[pq->size - 1];
    pq->size--;
    heapifyDown(pq, 0);
    return top;
}

bool findSafeWalk(int** grid, int gridSize, int* gridColSize, int health) {
    int m = gridSize, n = gridColSize[0];
    
    PriorityQueue* pq = createPQ(10000);
    bool visited[100][100] = {false}; // Assuming constraints
    
    push(pq, (State){health - grid[0][0], 0, 0});
    int directions[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    
    while (pq->size > 0) {
        State curr = pop(pq);
        
        if (curr.health <= 0) continue;
        if (curr.row == m-1 && curr.col == n-1) return true;
        if (visited[curr.row][curr.col]) continue;
        
        visited[curr.row][curr.col] = 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 && !visited[newRow][newCol]) {
                    push(pq, (State){newHealth, newRow, newCol});
                }
            }
        }
    }
    
    free(pq->data);
    free(pq);
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n*health * log(m*n*health))

Each of the m*n*health states can be processed once, with log factor for priority queue operations

⚡ Linearithmic

Space Complexity

O(m*n*health)

Priority queue and visited array can store 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

Dijkstra's Algorithm (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler