Shortest Bridge

Shortest Bridge - Problem

You are given an n x n binary matrix grid where 1 represents land and 0 represents water.

An island is a 4-directionally connected group of 1's not connected to any other 1's. There are exactly two islands in grid.

You may change 0's to 1's to connect the two islands to form one island.

Return the smallest number of 0's you must flip to connect the two islands.

Input & Output

Example 1 — Basic 3x3 Grid

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

› Output: 2

💡 Note: Island 1 is at (0,1), Island 2 is at (2,2). Shortest path: (0,1) → (1,1) → (1,2) → (2,2), requiring 2 flips at (1,1) and (1,2).

Example 2 — Adjacent Islands

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

› Output: 1

💡 Note: Large outer island surrounds inner island at (2,2). Only need to flip one adjacent cell like (1,2) or (2,1) to connect them.

Example 3 — Corner Islands

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

› Output: 3

💡 Note: Islands at opposite corners (0,0) and (2,2). Shortest 4-directional path requires 3 flips: (0,0) → (1,0) → (1,1) → (1,2) → (2,2), flipping cells (1,0), (1,1), and (1,2).

Constraints

n == grid.length == grid[i].length
2 ≤ n ≤ 100
grid[i][j] is either 0 or 1
There are exactly two islands in grid

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 f Facebook 8 M Microsoft 6

The key insight is to use multi-source BFS from the boundary of one island to find the shortest path to the other island. Best approach uses DFS + BFS: first mark one complete island, then BFS from its boundary. Time: O(n²), Space: O(n²)

Common Approaches

✓ BFS - Multi-Source Shortest Path

⏱️ Time: O(n²) Space: O(n²)

First, use DFS to identify and mark one complete island. Then perform multi-source BFS starting from all boundary cells of the first island, expanding outward until we reach the second island. This finds the shortest bridge length.

Brute Force - All Pairs Distance

⏱️ Time: O(n⁴) Space: O(n²)

Find all cells of both islands using DFS, then compute Manhattan distance between every pair of cells from different islands. Return the minimum distance minus 1.

BFS - Multi-Source Shortest Path — Algorithm Steps

Use DFS to find and mark first island completely
Add all boundary cells of first island to BFS queue
Perform BFS expanding outward layer by layer
Stop when we reach any cell of the second island
Return the number of steps taken

Visualization

Tap to expand

Step-by-Step Walkthrough

Mark Island

DFS marks first island with value 2

Find Boundary

Add boundary cells to BFS queue

BFS Expansion

Expand layer by layer until reaching second island

Code -

solution.c — C

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

typedef struct {
    int row;
    int col;
    int dist;
} QueueNode;

typedef struct {
    QueueNode* data;
    int front;
    int rear;
    int capacity;
} Queue;

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

void enqueue(Queue* queue, int row, int col, int dist) {
    queue->data[queue->rear].row = row;
    queue->data[queue->rear].col = col;
    queue->data[queue->rear].dist = dist;
    queue->rear++;
}

QueueNode dequeue(Queue* queue) {
    return queue->data[queue->front++];
}

int isEmpty(Queue* queue) {
    return queue->front == queue->rear;
}

void freeQueue(Queue* queue) {
    free(queue->data);
    free(queue);
}

void dfs(int** grid, int n, int row, int col, Queue* queue) {
    if (row < 0 || row >= n || col < 0 || col >= n || grid[row][col] != 1) {
        return;
    }
    
    grid[row][col] = 2;
    enqueue(queue, row, col, 0);
    
    dfs(grid, n, row + 1, col, queue);
    dfs(grid, n, row - 1, col, queue);
    dfs(grid, n, row, col + 1, queue);
    dfs(grid, n, row, col - 1, queue);
}

int solution(int** grid, int n) {
    Queue* queue = createQueue(n * n);
    
    int foundFirst = 0;
    
    for (int i = 0; i < n && !foundFirst; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) {
                dfs(grid, n, i, j, queue);
                foundFirst = 1;
                break;
            }
        }
    }
    
    int directions[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    
    while (!isEmpty(queue)) {
        QueueNode current = dequeue(queue);
        
        for (int d = 0; d < 4; d++) {
            int newRow = current.row + directions[d][0];
            int newCol = current.col + directions[d][1];
            
            if (newRow >= 0 && newRow < n && newCol >= 0 && newCol < n) {
                if (grid[newRow][newCol] == 1) {
                    freeQueue(queue);
                    return current.dist;
                }
                
                if (grid[newRow][newCol] == 0) {
                    grid[newRow][newCol] = 2;
                    enqueue(queue, newRow, newCol, current.dist + 1);
                }
            }
        }
    }
    
    freeQueue(queue);
    return 0;
}

int main() {
    char line[100000];
    
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    
    int n = 0;
    int bracketDepth = 0;
    for (int i = 0; line[i] != '\0'; i++) {
        if (line[i] == '[') {
            bracketDepth++;
            if (bracketDepth == 2) {
                n++;
            }
        } else if (line[i] == ']') {
            bracketDepth--;
        }
    }
    
    if (n == 0) return 1;
    
    int** grid = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
    }
    
    char* ptr = line;
    int row = 0;
    int col = 0;
    bracketDepth = 0;
    
    while (*ptr) {
        if (*ptr == '[') {
            bracketDepth++;
            if (bracketDepth == 2) {
                col = 0;
            }
        } else if (*ptr == ']') {
            if (bracketDepth == 2 && col > 0) {
                row++;
            }
            bracketDepth--;
        } else if ((*ptr == '0' || *ptr == '1') && bracketDepth == 2) {
            if (row < n && col < n) {
                grid[row][col++] = *ptr - '0';
            }
        }
        ptr++;
    }
    
    int result = solution(grid, n);
    
    printf("%d\n", result);
    
    for (int i = 0; i < n; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

DFS visits each cell once O(n²), BFS visits each cell at most once O(n²)

✓ Linear Growth

Space Complexity

O(n²)

BFS queue can contain up to O(n²) cells in worst case

⚠ Quadratic Space

89.0K Views

Medium Frequency

~25 min Avg. Time

2.1K 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 - Multi-Source Shortest Path — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler