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

 思路：

这道题和岛屿数量差不多，但是本题要求是封闭的才算，因此在搜索的时候需要加一个标志位判断这次搜索能否到边界，如果边界有陆地证明这次搜索的连通区域不是封闭岛屿。

这道题就是去搜索数字0，要将搜索到的0变成1，这样这次搜索完毕后，下次搜索可以避免重复搜到一样的。

要注意如果在某次搜索过程中，判断出不封闭，不要结束搜索，仍要进行继续遍历，要把和这个边界连着的所有零都置成1，以便下次搜索。

bfs代码如下：

class Solution {
public:
    int dir[4][2]={-1,0,1,0,0,-1,0,1};
    void bfs(vector<vector<int>>& grid,int x,int y,bool &isclose)
    {
        queue<pair<int,int>> que;
        que.push({x,y});
        grid[x][y]=1;
        while(!que.empty())
        {
            auto cur=que.front();
            int curx=cur.first;
            int cury=cur.second;
            que.pop();
            if(curx==0||curx==grid.size()-1||cury==0||cury==grid[0].size()-1)
            {
                isclose=false;
            }
            for(int i=0;i<4;i++)
            {
                int nextx=curx+dir[i][0];
                int nexty=cury+dir[i][1];
                if(nextx<0||nextx>=grid.size()||nexty<0||nexty>=grid[0].size())
                {
                    continue;
                }
                if(grid[nextx][nexty]==0)
                {
                    grid[nextx][nexty]=1;
                    que.push({nextx,nexty});
                }
            }
        }
    }
    int closedIsland(vector<vector<int>>& grid) {
        int n=grid.size();
        int m=grid[0].size();
        int result=0;
        bool isclose=true;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(grid[i][j]==0)
                {
                    bfs(grid,i,j,isclose);
                    if(isclose)
                    {
                        result++;
                    }
                    else
                    {
                        isclose=true;
                    }
                }
            }
        }
        return result;
    }
};

dfs代码如下：

class Solution {
public:
    int dir[4][2]={-1,0,1,0,0,-1,0,1};
    void dfs(vector<vector<int>>& grid,int x,int y,bool &isclose)
    {
        grid[x][y]=1;
        if(x==0||x==grid.size()-1||y==0||y==grid[0].size()-1)
        {
            isclose=false;
        }
        for(int i=0;i<4;i++)
        {
            int nextx=x+dir[i][0];
            int nexty=y+dir[i][1];
            if(nextx<0||nextx>=grid.size()||nexty<0||nexty>=grid[0].size())
            {
                continue;
            }
            if(grid[nextx][nexty]==0)
            {
                grid[nextx][nexty]=1;
                dfs(grid,nextx,nexty,isclose);
            }
        }
    }
    int closedIsland(vector<vector<int>>& grid) {
        int n=grid.size();
        int m=grid[0].size();
        int result=0;
        bool isclose=true;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(grid[i][j]==0)
                {
                    dfs(grid,i,j,isclose);
                    if(isclose)
                    {
                        result++;
                    }
                    else
                    {
                        isclose=true;
                    }
                }
            }
        }
        return result;
    }
};