Minimum Number of Days to Disconnect Island

Minimum Number of Days to Disconnect Island - Problem

Array Depth-First Search Breadth-First Search Matrix Strongly Connected Component Hard

You are given an m x n binary grid where 1 represents land and 0 represents water. An island is a maximal 4-directionally connected group of land cells (horizontal or vertical connections only).

The grid is considered connected if it contains exactly one island, otherwise it's disconnected.

Your mission: Find the minimum number of days needed to disconnect the grid, where each day you can convert exactly one land cell (1) into water (0).

Key insight: The answer is always 0, 1, or 2! If the grid is already disconnected, return 0. If removing any single land cell disconnects it, return 1. Otherwise, you can always disconnect any connected island by removing at most 2 strategically chosen cells.

Input & Output

example_1.py — Simple 2x2 Grid

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

› Output: 2

💡 Note: The island is a 2x2 square. No single cell removal can disconnect it, but removing any 2 adjacent cells will split it into separate parts.

example_2.py — Linear Island

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

› Output: 2

💡 Note: Even though it's just 2 cells, we need to remove both to have 0 islands (which counts as disconnected).

example_3.py — Already Disconnected

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

› Output: 0

💡 Note: There are already 2 separate islands, so the grid is already disconnected.

Visualization

Tap to expand

Understanding the Visualization

Analyze Structure

Count current islands - if not exactly 1, already disconnected

Find Critical Points

Test each land cell - some act as crucial bridges

Apply Mathematics

Graph theory guarantees any connected component can be split with ≤2 removals

Key Takeaway

🎯 Key Insight: The mathematical guarantee that any connected graph can be disconnected by removing at most 2 vertices simplifies this problem dramatically!

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of O(mn) pairs of cells, we run DFS/BFS which takes O(mn) time

⚠ Quadratic Growth

Space Complexity

O(mn)

Space for visited array in DFS/BFS traversal

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 30
grid[i][j] is either 0 or 1
The grid has at most one island

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 5

The optimal solution leverages a key insight: any connected island can be disconnected in at most 2 days. First check if already disconnected (return 0), then test if removing any single critical cell disconnects it (return 1), otherwise return 2 (guaranteed maximum).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(m²n²)	O(mn)	Try removing each cell, then each pair of cells until island disconnects

Brute Force (Try All Combinations) — Algorithm Steps

Count islands in original grid - if not exactly 1, return 0
Try removing each land cell and check if islands != 1, return 1
Try removing each pair of land cells and check connectivity
If any pair works, return 2 (guaranteed to work for any connected island)

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Original

Count islands in original grid

Try Single Cells

Remove each land cell and test connectivity

Return Result

If single cell works return 1, else return 2

Code -

solution.c — C

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

int dirs[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
int m, n;

void dfs(int** grid, bool** visited, int i, int j) {
    if (i < 0 || i >= m || j < 0 || j >= n || visited[i][j] || grid[i][j] == 0) return;
    visited[i][j] = true;
    for (int d = 0; d < 4; d++) {
        dfs(grid, visited, i + dirs[d][0], j + dirs[d][1]);
    }
}

int countIslands(int** grid) {
    bool** visited = (bool**)malloc(m * sizeof(bool*));
    for (int i = 0; i < m; i++) {
        visited[i] = (bool*)calloc(n, sizeof(bool));
    }
    
    int islands = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1 && !visited[i][j]) {
                dfs(grid, visited, i, j);
                islands++;
            }
        }
    }
    
    for (int i = 0; i < m; i++) free(visited[i]);
    free(visited);
    return islands;
}

int minDays(int** grid, int gridSize, int* gridColSize) {
    m = gridSize;
    n = gridColSize[0];
    
    if (countIslands(grid) != 1) return 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) {
                grid[i][j] = 0;
                if (countIslands(grid) != 1) return 1;
                grid[i][j] = 1;
            }
        }
    }
    
    return 2;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of O(mn) pairs of cells, we run DFS/BFS which takes O(mn) time

⚠ Quadratic Growth

Space Complexity

O(mn)

Space for visited array in DFS/BFS traversal

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 30
grid[i][j] is either 0 or 1
The grid has at most one island

28.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler