Minimum Obstacle Removal to Reach Corner - Practice Coding Problems

Minimum Obstacle Removal to Reach Corner - Problem

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

Navigate Through a Grid Maze: You're given a rectangular grid where you need to find the shortest path from the top-left corner to the bottom-right corner. However, this isn't just any ordinary pathfinding problem!

Each cell in the grid contains either:

0 - An empty cell you can walk through freely
1 - An obstacle that blocks your path, but can be removed at a cost

You can move in four directions: up, down, left, right. The challenge is to find the minimum number of obstacles you need to remove to create a path from (0,0) to (m-1,n-1).

Goal: Return the minimum number of obstacles that must be removed to reach the destination.

Input & Output

example_1.py — Basic 3x3 Grid

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

› Output: 2

💡 Note: We can remove the obstacles at (0,1) and (0,2) to create path: (0,0) → (0,1) → (0,2) → (1,2) → (2,2). This requires removing 2 obstacles total.

example_2.py — All Empty Cells

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

› Output: 0

💡 Note: We can reach the destination without removing any obstacles. One possible path: (0,0) → (0,1) → (0,2) → (1,2) → (2,2).

example_3.py — Single Path Through Obstacles

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

› Output: 1

💡 Note: The optimal path removes only 1 obstacle at (2,3): (0,0) → (1,0) → (2,0) → (2,1) → (2,2) → (2,3) → (2,4). Only the obstacle at (2,3) needs to be removed.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 10⁵
2 ≤ m * n ≤ 10⁵
grid[i][j] is either 0 or 1
grid[0][0] == grid[m-1][n-1] == 0

Visualization

Tap to expand

Understanding the Visualization

Start at entrance

Begin at top-left corner (0,0) with 0 obstacles removed

Smart exploration

Use 0-1 BFS: free paths get higher priority (front of deque)

Cost tracking

Obstacle paths get lower priority (back of deque)

Optimal guarantee

First time reaching destination gives minimum obstacles

Efficient processing

Each cell visited at most once due to optimal substructure

Key Takeaway

🎯 Key Insight: Since we only have two costs (0 and 1), 0-1 BFS with a deque is more efficient than general Dijkstra's algorithm, achieving optimal O(mn) time complexity.

Asked in

G Google 45 a Amazon 38 f Meta 22 ⊞ Microsoft 31

The optimal solution uses 0-1 BFS with a deque to efficiently find the minimum obstacles to remove. Since we only have two edge weights (0 for empty cells, 1 for obstacles), we can use a deque where cost-0 moves are added to the front and cost-1 moves are added to the back. This ensures we always process the path with minimum obstacles first, achieving O(mn) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dijkstra's Algorithm with Priority Queue	O(mn log(mn))	O(m*n)	Use Dijkstra's shortest path algorithm to find minimum obstacles
Brute Force (DFS with Backtracking)	O(4^(m*n))	O(m*n)	Try all possible paths using DFS and track minimum obstacles removed
0-1 BFS with Deque (Optimal)	O(m*n)	O(m*n)	Use 0-1 BFS with deque to find shortest path in O(mn) time

Dijkstra's Algorithm with Priority Queue — Algorithm Steps

Initialize distance array with infinity, set dist[0][0] = 0
Use min-heap priority queue with (distance, row, col)
Pop minimum distance cell from queue
If reached destination, return distance
Update neighbors if shorter path is found
Continue until destination is processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize distances

Set all distances to infinity except source (0,0) = 0

Use priority queue

Always process the cell with minimum distance first

Relax neighbors

Update neighbor distances if shorter path found

Mark as processed

Once popped from queue, distance is finalized

Continue until target

First time we process target gives optimal distance

Code -

solution.c — C

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

typedef struct {
    int dist, row, col;
} Node;

// Simple priority queue implementation for demonstration
typedef struct {
    Node* data;
    int size;
    int capacity;
} PriorityQueue;

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

void push(PriorityQueue* pq, Node node) {
    if (pq->size < pq->capacity) {
        pq->data[pq->size++] = node;
    }
}

Node pop(PriorityQueue* pq) {
    int minIdx = 0;
    for (int i = 1; i < pq->size; i++) {
        if (pq->data[i].dist < pq->data[minIdx].dist) {
            minIdx = i;
        }
    }
    Node result = pq->data[minIdx];
    // Move last element to minIdx position
    pq->data[minIdx] = pq->data[--pq->size];
    return result;
}

int isEmpty(PriorityQueue* pq) {
    return pq->size == 0;
}

int minimumObstacles(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = gridColSize[0];
    
    // Initialize distance array
    int** dist = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        dist[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            dist[i][j] = INT_MAX;
        }
    }
    dist[0][0] = 0;
    
    PriorityQueue* pq = createPQ(m * n * 4);
    push(pq, (Node){0, 0, 0});
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    while (!isEmpty(pq)) {
        Node curr = pop(pq);
        int d = curr.dist, row = curr.row, col = curr.col;
        
        if (d > dist[row][col]) continue;
        
        if (row == m - 1 && col == n - 1) {
            // Cleanup
            for (int i = 0; i < m; i++) {
                free(dist[i]);
            }
            free(dist);
            free(pq->data);
            free(pq);
            return d;
        }
        
        for (int i = 0; i < 4; i++) {
            int newRow = row + directions[i][0];
            int newCol = col + directions[i][1];
            
            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n) {
                int newDist = d + grid[newRow][newCol];
                
                if (newDist < dist[newRow][newCol]) {
                    dist[newRow][newCol] = newDist;
                    push(pq, (Node){newDist, newRow, newCol});
                }
            }
        }
    }
    
    int result = dist[m-1][n-1];
    
    // Cleanup
    for (int i = 0; i < m; i++) {
        free(dist[i]);
    }
    free(dist);
    free(pq->data);
    free(pq);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn log(mn))

Each cell can be added to priority queue once, heap operations take O(log(mn))

⚡ Linearithmic

Space Complexity

O(m*n)

Distance array and priority queue space

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Dijkstra's Algorithm with Priority Queue — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler