Number of Closed Islands

Number of Closed Islands - Problem

Given a 2D grid consisting of 0s (land) and 1s (water), an island is a maximal 4-directionally connected group of 0s.

A closed island is an island that is totally surrounded by 1s on all sides (left, top, right, bottom).

Return the number of closed islands.

Input & Output

Example 1 — Basic Closed Island

$ 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: There are two closed islands: one 2x2 island in the middle-left area, and one single cell island. The rightmost land cells touch the boundary so they don't count.

Example 2 — No Closed Islands

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

› Output: 0

💡 Note: All land cells are connected to the boundary (top, bottom, left, or right edges), so there are no closed islands.

Example 3 — Single Closed Island

$ 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: The center island is completely surrounded by water (1s). The single land cell in the middle is also connected to the outer ring, forming one large closed island.

Constraints

1 ≤ grid.length, grid[i].length ≤ 100
grid[i][j] is 0 or 1

Visualization

Tap to expand

Asked in

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

The key insight is that a closed island cannot touch the grid boundary. Best approach is Two-Pass DFS: first mark all boundary-connected land, then count remaining island groups. Time: O(m×n), Space: O(m×n)

Common Approaches

✓ Brute Force DFS

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

Iterate through every cell in the grid. When we find an unvisited land cell (0), perform DFS to explore the entire connected component. During DFS, track if any cell touches the boundary. If no boundary is touched, increment the closed island count.

Two-Pass DFS

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

Use a two-pass approach: first, perform DFS from all boundary land cells to mark them as 'not closed'. Then, iterate through the grid again and count islands formed by unmarked land cells.

Brute Force DFS — Algorithm Steps

Iterate through each cell in the grid
For each unvisited land cell, start DFS
During DFS, mark cells as visited and check if any cell touches boundary
If entire island doesn't touch boundary, increment count

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Land

Scan grid for unvisited land cells (0)

DFS Explore

Use DFS to visit all connected land cells

Check Boundary

Track if any cell touches grid boundary

Count Closed

Increment count if island doesn't touch boundary

Code -

solution.c — C

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

bool dfs(int** grid, bool** visited, int i, int j, int m, int n) {
    if (i < 0 || i >= m || j < 0 || j >= n || visited[i][j] || grid[i][j] == 1) {
        return true;
    }
    
    visited[i][j] = true;
    
    bool isClosed = true;
    if (i == 0 || i == m-1 || j == 0 || j == n-1) {
        isClosed = false;
    }
    
    isClosed &= dfs(grid, visited, i+1, j, m, n);
    isClosed &= dfs(grid, visited, i-1, j, m, n);
    isClosed &= dfs(grid, visited, i, j+1, m, n);
    isClosed &= dfs(grid, visited, i, j-1, m, n);
    
    return isClosed;
}

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

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    static char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Remove outer brackets
    char* start = strchr(line, '[');
    if (!start) {
        printf("0\n");
        return 0;
    }
    start++; // Skip first [
    
    char* end = strrchr(line, ']');
    if (!end || end <= start) {
        printf("0\n");
        return 0;
    }
    *end = '\0'; // Remove last ]
    
    static int grid_data[1000][1000];
    int** grid = (int**)malloc(1000 * sizeof(int*));
    for (int i = 0; i < 1000; i++) {
        grid[i] = grid_data[i];
    }
    
    int m = 0;
    char* p = start;
    
    while (*p) {
        // Find start of row
        while (*p && *p != '[') p++;
        if (!*p) break;
        
        // Find end of row
        char* row_start = p;
        char* row_end = strchr(p, ']');
        if (!row_end) break;
        
        // Extract row string
        static char row_str[10000];
        int row_len = row_end - row_start + 1;
        strncpy(row_str, row_start, row_len);
        row_str[row_len] = '\0';
        
        // Parse row
        static int temp_arr[1000];
        int n;
        parseArray(row_str, temp_arr, &n);
        
        // Copy to grid
        for (int j = 0; j < n; j++) {
            grid[m][j] = temp_arr[j];
        }
        
        if (m == 0) {
            // First row determines n
        }
        
        m++;
        p = row_end + 1;
    }
    
    int n = 0;
    if (m > 0) {
        // Determine n from first row
        char* first_row = start;
        while (*first_row && *first_row != '[') first_row++;
        if (*first_row) {
            char* first_row_end = strchr(first_row, ']');
            if (first_row_end) {
                static char first_row_str[10000];
                int first_row_len = first_row_end - first_row + 1;
                strncpy(first_row_str, first_row, first_row_len);
                first_row_str[first_row_len] = '\0';
                
                static int temp_arr[1000];
                parseArray(first_row_str, temp_arr, &n);
            }
        }
    }
    
    int result = solution(grid, m, n);
    printf("%d\n", result);
    
    free(grid);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Visit each cell at most once during DFS traversal

✓ Linear Growth

Space Complexity

O(m×n)

Recursion depth can go up to m×n in worst case (entire grid is one island)

⚡ Linearithmic Space

89.2K Views

Medium Frequency

~15 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

Brute Force DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler