Number of Closed Islands - Practice Coding Problems

Number of Closed Islands - Problem

Imagine exploring a vast archipelago where islands are scattered across the ocean! You're given a 2D grid representing this maritime landscape, where 0 represents land and 1 represents water.

An island is a group of connected land cells (0s) that are adjacent horizontally or vertically. But here's the twist: we're only interested in closed islands - islands that are completely surrounded by water on all sides, including the boundaries of the grid.

Goal: Count how many closed islands exist in this grid. An island touching the edge of the grid doesn't count as closed since it's not completely surrounded by water!

Example: In a grid where land extends to the border, those border islands are not closed because they're not fully encircled by water.

Input & Output

example_1.py — Basic Grid

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

› Output: 1

💡 Note: The 2x2 land area in the middle is completely surrounded by water, making it a closed island. Count = 1.

example_2.py — Multiple Islands

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

› Output: 0

💡 Note: All land areas touch the boundary (edges of grid), so no islands are completely closed. Count = 0.

example_3.py — Complex Layout

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

› Output: 2

💡 Note: Two closed islands exist: one small island and one larger island, both completely surrounded by water.

Constraints

1 ≤ grid.length, grid[i].length ≤ 100
grid[i][j] is 0 (land) or 1 (water)
Islands are formed by connecting adjacent land cells horizontally or vertically

Visualization

Tap to expand

Understanding the Visualization

Boundary Sweep

Start from all edges and mark connected land as 'boundary islands'

Elimination Phase

All boundary-connected land becomes water (eliminated)

Counting Phase

Count remaining isolated land masses - these are closed islands

Key Takeaway

🎯 Key Insight: Instead of checking if each island is closed, eliminate all open (boundary-connected) islands first, then count what remains!

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28 Apple 22

The optimal solution uses a two-pass DFS approach: first eliminate all boundary-connected islands by marking them as water, then count remaining land clusters as closed islands. This avoids redundant boundary checking and achieves O(m×n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass DFS (Boundary Elimination)	O(m×n)	O(m×n)	First pass eliminates boundary-connected islands, second pass counts remaining closed islands

Two-Pass DFS (Boundary Elimination) — Algorithm Steps

First pass: Start DFS from all boundary land cells (edges of grid)
Mark all land cells connected to boundaries as 'visited' or change to water
Second pass: Count all remaining unmarked land clusters
Each remaining cluster is guaranteed to be a closed island

Visualization

Tap to expand

Step-by-Step Walkthrough

Mark Boundary Lands

Start DFS from all boundary land cells

Eliminate Connected

Mark all boundary-connected land as water

Count Remaining

Count all remaining land clusters as closed islands

Code -

solution.c — C

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

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

int closedIsland(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) return 0;
    
    int m = gridSize, n = gridColSize[0];
    
    // First pass: eliminate boundary-connected islands
    for (int j = 0; j < n; j++) {
        if (grid[0][j] == 0) dfs(grid, 0, j, m, n);
        if (grid[m-1][j] == 0) dfs(grid, m-1, j, m, n);
    }
    
    for (int i = 0; i < m; i++) {
        if (grid[i][0] == 0) dfs(grid, i, 0, m, n);
        if (grid[i][n-1] == 0) dfs(grid, i, n-1, m, n);
    }
    
    // Second pass: count remaining closed islands
    int count = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 0) {
                dfs(grid, i, j, m, n);
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int grid[4][5] = {{1,1,1,1,1},{1,0,0,1,1},{1,0,0,1,1},{1,1,1,1,1}};
    int* gridRows[4];
    for (int i = 0; i < 4; i++) {
        gridRows[i] = grid[i];
    }
    int gridColSize[4] = {5,5,5,5};
    printf("%d\n", closedIsland(gridRows, 4, gridColSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Two passes through grid, each cell visited at most twice

✓ Linear Growth

Space Complexity

O(m×n)

Recursion stack or visited array, worst case is entire grid

⚡ Linearithmic Space

28.5K Views

Medium-High Frequency

~18 min Avg. Time

1.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

Two-Pass DFS (Boundary Elimination) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler