LeetCode //C - 1254. Number of Closed Islands

Navigator_Z2026-09-21 13:39

1254. Number of Closed Islands

Given a 2D grid consists of 0s (land) and 1s (water). An island is a maximal 4-directionally connected group of 0s and a closed island is an island totally (all left, top, right, bottom) surrounded by 1s.

Return the number of closed islands.

Example 1:

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

Explanation:

Islands in gray are closed because they are completely surrounded by water (group of 1s).

Example 2:

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

Output: 1

Example 3:

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

$1,0,0,0,0,0,1$ ,

$1,0,1,1,1,0,1$ ,

$1,0,1,0,1,0,1$ ,

$1,0,1,1,1,0,1$ ,

$1,0,0,0,0,0,1$ ,
$1,1,1,1,1,1,1\]$
Output: 2

Constraints:

1 <= grid.length, grid $0$ .length <= 100
0 <= grid $i$ $j$ <=1

From: LeetCode

Link: 1254. Number of Closed Islands

Solution:

Ideas:

first flood-fill all land touching the border, because it cannot be closed. Then count the remaining land groups.

Code:

c 复制代码

void dfs(int** grid, int r, int c, int m, int n) {
    if (r < 0 || r >= m || c < 0 || c >= n || grid[r][c] == 1)
        return;

    grid[r][c] = 1; // mark visited

    dfs(grid, r + 1, c, m, n);
    dfs(grid, r - 1, c, m, n);
    dfs(grid, r, c + 1, m, n);
    dfs(grid, r, c - 1, m, n);
}

int closedIsland(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize;
    int n = gridColSize[0];
    int count = 0;

    // remove all land connected to border
    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);
    }

    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);
    }

    // remaining land must be closed islands
    for (int i = 1; i < m - 1; i++) {
        for (int j = 1; j < n - 1; j++) {
            if (grid[i][j] == 0) {
                count++;
                dfs(grid, i, j, m, n);
            }
        }
    }

    return count;
}