Shortest Path in a Grid with Obstacles Elimination

Shortest Path in a Grid with Obstacles Elimination - Problem

You're navigating through a dangerous maze represented by an m × n grid where each cell is either 0 (safe passage) or 1 (deadly obstacle). Your mission: find the shortest path from the top-left corner (0, 0) to the bottom-right corner (m-1, n-1).

Here's the twist: you have a special power that allows you to eliminate up to k obstacles along your journey! You can move in four directions (up, down, left, right), but only through empty cells or obstacles you choose to eliminate.

Goal: Return the minimum number of steps needed to reach the destination. If it's impossible even with your obstacle-elimination power, return -1.

Example: In a 3×3 grid with obstacles, you might need to eliminate 1 obstacle to create the shortest path of 6 steps instead of taking a longer detour.

Input & Output

example_1.py — Basic Grid with Obstacles

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

› Output: 6

💡 Note: The shortest path without eliminating obstacles would be (0,0)→(1,0)→(2,0)→(2,1)→(2,2) = 4 steps, but there's an obstacle at (1,0). With k=1, we can eliminate one obstacle: optimal path is (0,0)→(0,1)→(0,2)→(1,2)→(2,2) = 4 steps, or eliminate obstacle at (1,1) for a different 6-step path.

example_2.py — Straight Line Path

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

› Output: -1

💡 Note: Even with 1 elimination, we cannot reach the destination. We need at least 2 eliminations to create any viable path from start to end.

example_3.py — Optimal Elimination Usage

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

› Output: 12

💡 Note: The grid has a maze-like structure. With k=1, we can eliminate one strategic obstacle to create the shortest path of 12 steps, rather than taking a much longer route around the obstacles.

Visualization

Tap to expand

Understanding the Visualization

Deploy Robot

Robot starts at top-left with k blast shields available

Navigate Smartly

Use BFS to explore all paths simultaneously, tracking position and remaining shields

Make Decisions

At each mine, decide: use a shield or find alternate route

Reach Target

First arrival at bomb location is guaranteed to be the fastest route

Key Takeaway

🎯 Key Insight: BFS with 3D state (row, col, shields_left) ensures we find the shortest path while optimally managing our limited resources. The first time we reach the destination is guaranteed to be optimal!

Time & Space Complexity

Time Complexity

⏱️

O(m*n*k)

We might visit each cell with each possible elimination count, and BFS visits each state at most once

✓ Linear Growth

Space Complexity

O(m*n*k)

Queue and visited set can store up to m*n*k states

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 40
1 ≤ k ≤ m × n
grid[i][j] is either 0 or 1
grid[0][0] == grid[m-1][n-1] == 0

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses BFS with 3D state tracking (row, col, eliminations_remaining). This guarantees finding the shortest path while efficiently managing the elimination budget. Key insight: treat each combination of position and remaining eliminations as a unique state to avoid cycles while exploring all viable paths.

Common Approaches

Approach	Time	Space	Notes
✓ BFS with State Space (Optimal)	O(mnk)	O(mnk)	Use BFS with 3D state (row, col, eliminations_left) to find shortest path

BFS with State Space (Optimal) — Algorithm Steps

Initialize queue with starting state (0, 0, k, 0_steps)
Use 3D visited set to track (row, col, eliminations_remaining)
For each position, try moving in all 4 directions
If next cell is obstacle, use one elimination (if available)
If we reach destination, return current steps
Mark states as visited to avoid cycles

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with state (0,0,k)

Level-by-Level

BFS explores all states at distance d before d+1

State Tracking

Track (row, col, eliminations_left) to avoid cycles

First Arrival

First time reaching destination = shortest path

Code -

solution.c — C

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

#define MAX_QUEUE 100000
#define MAX_VISITED 100000

typedef struct {
    int row, col, eliminations, steps;
} State;

typedef struct {
    char key[50];
} VisitedState;

int shortestPath(int grid[][100], int m, int n, int k) {
    if (k >= m + n - 2) {
        return m + n - 2;
    }
    
    State queue[MAX_QUEUE];
    VisitedState visited[MAX_VISITED];
    int front = 0, rear = 0, visitedCount = 0;
    
    queue[rear++] = (State){0, 0, k, 0};
    sprintf(visited[visitedCount++].key, "0,0,%d", k);
    
    int directions[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    
    while (front < rear) {
        State current = queue[front++];
        
        if (current.row == m - 1 && current.col == n - 1) {
            return current.steps;
        }
        
        for (int i = 0; i < 4; i++) {
            int newRow = current.row + directions[i][0];
            int newCol = current.col + directions[i][1];
            
            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n) {
                int newEliminations = current.eliminations;
                
                if (grid[newRow][newCol] == 1) {
                    if (current.eliminations > 0) {
                        newEliminations = current.eliminations - 1;
                    } else {
                        continue;
                    }
                }
                
                char stateKey[50];
                sprintf(stateKey, "%d,%d,%d", newRow, newCol, newEliminations);
                
                int found = 0;
                for (int j = 0; j < visitedCount; j++) {
                    if (strcmp(visited[j].key, stateKey) == 0) {
                        found = 1;
                        break;
                    }
                }
                
                if (!found && visitedCount < MAX_VISITED) {
                    strcpy(visited[visitedCount++].key, stateKey);
                    queue[rear++] = (State){newRow, newCol, newEliminations, current.steps + 1};
                }
            }
        }
    }
    
    return -1;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n*k)

We might visit each cell with each possible elimination count, and BFS visits each state at most once

✓ Linear Growth

Space Complexity

O(m*n*k)

Queue and visited set can store up to m*n*k states

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 40
1 ≤ k ≤ m × n
grid[i][j] is either 0 or 1
grid[0][0] == grid[m-1][n-1] == 0

52.1K Views

Medium-High 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

BFS with State Space (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler