【深度优先搜索】leetcode 1254. 统计封闭岛屿的数目

1254. 统计封闭岛屿的数目

题目描述

二维矩阵 grid 由 0 （土地）和 1 （水）组成。岛是由最大的4个方向连通的 0 组成的群，封闭岛是一个 完全 由1包围（左、上、右、下）的岛。

请返回 封闭岛屿 的数目。

示例1：

输入： 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]]
输出： 2
解释： 灰色区域的岛屿是封闭岛屿，因为这座岛屿完全被水域包围（即被 1 区域包围）。

示例2：

输入： grid = [[0,0,1,0,0],[0,1,0,1,0],[0,1,1,1,0]]
输出： 1

示例3：

输入： 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]]
输出： 2

提示

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

方法：深度优先搜索

解题思路

我们可以从 $grid$ 中的任意一个 $0$ 开始，通过深度优先搜索，找出包含这个 $0$ 的全 $0$ 连通区域，即为一座岛屿。在搜索时，如果搜索的位置超出了边界，则当前连通区域中有 $0$ 是位于边界上的，那就说明它不是封闭岛屿，不计入答案。

代码

class Solution {
public:
    const int dx[4] = {1, 0, -1, 0};
    const int dy[4] = {0, 1, 0, -1};
    int tag;
    void dfs(vector<vector<int>>& grid, int x, int y) {
        if(grid[x][y] == 1) return;
        grid[x][y] = 1;
        for(int i = 0; i < 4; i++) {
            int mx = x + dx[i], my = y + dy[i];
            if(mx >= 0 && mx < grid.size() && my >= 0 && my < grid[0].size()) {
                dfs(grid, mx, my);
            } else {
                tag = 0;
            }
        }
    }
    int closedIsland(vector<vector<int>>& grid) {
        int nr = grid.size(), nc = grid[0].size();
        int cnt = 0;
        if(!nr) return 0;
        for(int r = 1; r < nr - 1; r++) 
            for(int c = 1; c < nc - 1; c++) 
                if(grid[r][c] == 0) {
                    tag = 1;
                    dfs(grid, r, c);
                    cnt += tag;
                }
        return cnt;
    }
};

复杂度分析

• 时间复杂度：$O(m\times n)$。其中 $m$ 是给定网格中的行数，$n$ 是列数。我们访问每个网格最多一次。
• 空间复杂度：$O(m\times n)$。递归的深度最大可能是整个网格的大小，因此最大可能使用 $O(m\times n)$ 的栈空间。