Shortest Bridge - Practice Coding Problems

Shortest Bridge - Problem

Shortest Bridge Problem: Imagine you're looking at a satellite map of an ocean with exactly two separate islands. You have the power to transform water into land, and your mission is to build the shortest possible bridge between these two islands.

You are given an n x n binary matrix where 1 represents land and 0 represents water. An island is a group of connected land cells (connected horizontally or vertically, not diagonally). The grid is guaranteed to contain exactly two islands.

Your Goal: Find the minimum number of water cells (0s) you need to flip to 1s to connect the two islands into one continuous landmass.

Example: If you have islands at opposite corners, you'd need to create a path of land connecting them. The shortest path requires the fewest water-to-land conversions.

Input & Output

example_1.py — Basic Bridge

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

› Output: 1

💡 Note: Two single-cell islands in opposite corners. We need to flip one water cell to connect them, creating either [[0,1],[1,1]] or [[1,1],[1,0]].

example_2.py — Larger Islands

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

› Output: 2

💡 Note: Island 1 is at (0,1) and Island 2 is at (2,2). The shortest path requires flipping 2 water cells: (1,1) and either (1,2) or (2,1).

example_3.py — Connected 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 single-cell island. Only need to flip 1 water cell to connect them.

Constraints

n == grid.length == grid[i].length
2 ≤ n ≤ 100
grid[i][j] is either 0 or 1
Exactly two islands are guaranteed to exist in the grid
An island is a 4-directionally connected group of 1's

Visualization

Tap to expand

Understanding the Visualization

Survey First Island

Use DFS to map out the entire first island and identify all coastal boundary points

Multi-Point Expansion

Start construction from ALL coastal points simultaneously using BFS

Wave Propagation

Construction expands outward like a wave, one step at a time across the water

Bridge Complete

Stop when the expanding wave reaches any point of the second island

Key Takeaway

🎯 Key Insight: Multi-source BFS from all boundary points of one island guarantees finding the shortest bridge to the other island, mimicking how water waves propagate uniformly in all directions.

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 25

The optimal approach uses DFS + BFS hybrid: First, identify one complete island using DFS, then use BFS to expand outward from all its boundary cells simultaneously until reaching the second island. This guarantees finding the shortest bridge in O(n²) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ DFS + BFS Hybrid (Two-Pass)	O(n²)	O(n²)	Use DFS to find one island, then BFS to expand until reaching the second island

DFS + BFS Hybrid (Two-Pass) — Algorithm Steps

Find any cell of the first island
Use DFS to mark all cells of the first island and collect boundary cells
Initialize BFS queue with all boundary cells of the first island
Expand BFS layer by layer until we reach a cell of the second island
Return the number of BFS steps taken

Visualization

Tap to expand

Step-by-Step Walkthrough

Find First Island

Use DFS to mark all cells of first island and collect boundary

Initialize BFS

Start BFS from all boundary cells of first island

Expand Layer by Layer

BFS expands outward one step at a time

Hit Second Island

Stop when BFS reaches any cell of second island

Code -

solution.c — C

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

#define QUEUE_SIZE 100000

typedef struct {
    int x, y, dist;
} QueueNode;

void dfs(int** grid, int n, int i, int j, QueueNode* queue, int* queueSize) {
    if (i < 0 || i >= n || j < 0 || j >= n || grid[i][j] != 1) return;
    
    grid[i][j] = 2;
    queue[(*queueSize)++] = (QueueNode){i, j, 0};
    
    int dirs[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    for (int d = 0; d < 4; d++) {
        dfs(grid, n, i + dirs[d][0], j + dirs[d][1], queue, queueSize);
    }
}

int shortestBridge(int** grid, int gridSize, int* gridColSize) {
    int n = gridSize;
    QueueNode queue[QUEUE_SIZE];
    int queueSize = 0;
    
    // Find first island
    int found = 0;
    for (int i = 0; i < n && !found; i++) {
        for (int j = 0; j < n && !found; j++) {
            if (grid[i][j] == 1) {
                dfs(grid, n, i, j, queue, &queueSize);
                found = 1;
            }
        }
    }
    
    // BFS to second island
    int front = 0;
    int dirs[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    
    while (front < queueSize) {
        QueueNode curr = queue[front++];
        
        for (int d = 0; d < 4; d++) {
            int nx = curr.x + dirs[d][0];
            int ny = curr.y + dirs[d][1];
            
            if (nx >= 0 && nx < n && ny >= 0 && ny < n) {
                if (grid[nx][ny] == 1) return curr.dist;
                if (grid[nx][ny] == 0) {
                    grid[nx][ny] = 2;
                    queue[queueSize++] = (QueueNode){nx, ny, curr.dist + 1};
                }
            }
        }
    }
    
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

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

⚠ Quadratic Growth

Space Complexity

O(n²)

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

⚠ Quadratic Space

41.2K Views

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

DFS + BFS Hybrid (Two-Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler