Minimum Obstacle Removal to Reach Corner

Minimum Obstacle Removal to Reach Corner - Problem

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

You are given a 0-indexed 2D integer array grid of size m x n. Each cell has one of two values:

0 represents an empty cell
1 represents an obstacle that may be removed

You can move up, down, left, or right from and to an empty cell.

Return the minimum number of obstacles to remove so you can move from the upper left corner (0, 0) to the lower right corner (m - 1, n - 1).

Input & Output

Example 1 — Basic Case

$ 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)

Example 2 — No Obstacles Needed

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

› Output: 0

💡 Note: Path exists without removing obstacles: (0,0) → (0,2) → (0,3) → (0,4) → (1,4) → (2,4)

Example 3 — Minimum Grid

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

› Output: 0

💡 Note: Simple path from (0,0) → (0,1) → (1,1) with no obstacles

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

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Meta 28

The key insight is to treat this as a shortest path problem where moving through empty cells costs 0 and removing obstacles costs 1. The optimal approach uses 0-1 BFS with deque to prioritize free moves over obstacle removals. Time: O(m*n), Space: O(m*n)

Common Approaches

✓ 0-1 BFS with Deque

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

Treat this as a shortest path problem where moving through empty cells has cost 0 and removing obstacles has cost 1. Use deque to add zero-cost moves to front and obstacle removals to back.

DFS with Backtracking

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

Use depth-first search to explore every possible path from start to end. For each cell, try moving in all 4 directions and keep track of obstacles removed. Backtrack when reaching dead ends.

Standard BFS

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

Apply standard BFS where each step represents moving to an adjacent cell. Track the number of obstacles removed for each path and use a queue to explore all possibilities level by level.

0-1 BFS with Deque — Algorithm Steps

Initialize deque with starting position
For each position, add moves through empty cells to front of deque
Add obstacle removal moves to back of deque
Return obstacles removed when reaching destination

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Deque

Start with (0,0) in deque

Prioritize Free Moves

Add moves through empty cells to front

Queue Obstacle Moves

Add obstacle removal moves to back

Code -

solution.c — C

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

#define MAX_SIZE 400010

struct State {
    int row, col, obstacles;
};

static struct State deque[MAX_SIZE];
static int visited[1000][1000];

int solution(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = gridColSize[0];
    int front = MAX_SIZE / 2, back = MAX_SIZE / 2;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            visited[i][j] = INT_MAX;
        }
    }
    
    deque[back++] = (struct State){0, 0, 0};
    visited[0][0] = 0;
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    while (front < back) {
        struct State curr = deque[front++];
        
        if (curr.row == m - 1 && curr.col == n - 1) {
            return curr.obstacles;
        }
        
        // Skip if we've already found a better path to this cell
        if (curr.obstacles > visited[curr.row][curr.col]) {
            continue;
        }
        
        for (int d = 0; d < 4; d++) {
            int nr = curr.row + directions[d][0];
            int nc = curr.col + directions[d][1];
            
            if (nr < 0 || nr >= m || nc < 0 || nc >= n) continue;
            
            int newObs = curr.obstacles + grid[nr][nc];
            
            if (newObs < visited[nr][nc]) {
                visited[nr][nc] = newObs;
                if (grid[nr][nc] == 0) {
                    // Weight 0 edge: push to front
                    deque[--front] = (struct State){nr, nc, newObs};
                } else {
                    // Weight 1 edge: push to back
                    deque[back++] = (struct State){nr, nc, newObs};
                }
            }
        }
    }
    
    return -1;
}

int parseGrid(const char* input, int*** grid, int* rows, int** colSizes) {
    // Count rows by counting inner '[' that start a row
    int m = 0, n = 0;
    const char* p = input;
    
    // Skip outer '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Count rows and parse
    int capacity = 10;
    *grid = malloc(capacity * sizeof(int*));
    *colSizes = malloc(capacity * sizeof(int));
    
    while (*p) {
        while (*p && *p != '[' && *p != ']') p++;
        if (*p == ']') break; // end of outer array
        if (*p == '[') {
            p++; // skip '['
            int colCap = 10, colCount = 0;
            int* row = malloc(colCap * sizeof(int));
            
            while (*p && *p != ']') {
                if (*p == '0' || *p == '1') {
                    if (colCount >= colCap) {
                        colCap *= 2;
                        row = realloc(row, colCap * sizeof(int));
                    }
                    row[colCount++] = *p - '0';
                }
                p++;
            }
            if (*p == ']') p++;
            
            if (m >= capacity) {
                capacity *= 2;
                *grid = realloc(*grid, capacity * sizeof(int*));
                *colSizes = realloc(*colSizes, capacity * sizeof(int));
            }
            (*grid)[m] = row;
            (*colSizes)[m] = colCount;
            m++;
        }
    }
    
    *rows = m;
    return m > 0;
}

int main() {
    char input[100000];
    if (!fgets(input, sizeof(input), stdin)) return 0;
    
    int** grid;
    int rows;
    int* colSizes;
    
    if (!parseGrid(input, &grid, &rows, &colSizes)) {
        printf("0\n");
        return 0;
    }
    
    int result = solution(grid, rows, colSizes);
    printf("%d\n", result);
    
    for (int i = 0; i < rows; i++) free(grid[i]);
    free(grid);
    free(colSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Each cell visited at most once with optimal obstacle count

✓ Linear Growth

Space Complexity

O(m*n)

Deque and distance array store up to m*n elements

⚡ Linearithmic Space

68.0K Views

High Frequency

~35 min Avg. Time

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

0-1 BFS with Deque — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler