leetcode 1254. 统计封闭岛屿的数目（C++、python）

有一个二维矩阵 grid ，每个位置要么是陆地（记号为 0 ）要么是水域（记号为 1 ）。

我们从一块陆地出发，每次可以往上下左右 4 个方向相邻区域走，能走到的所有陆地区域，我们将其称为一座「岛屿」。

如果一座岛屿 完全 由水域包围，即陆地边缘上下左右所有相邻区域都是水域，那么我们将其称为 「封闭岛屿」。

请返回封闭岛屿的数目。

 

示例 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

C++

const int dx[]={-1,1,0,0};
const int dy[]={0,0,-1,1};
class Solution {
public:
    void dfs(vector<vector<int>>& grid, vector<vector<int>>& flag, int* ss, int i, int j)
    {
        if(0==flag[i][j])
        {
            flag[i][j]=1;
            if(0==grid[i][j])
            {
                grid[i][j]=2;
                if(0==i || i==(grid.size()-1) || 0==j || j==(grid[0].size()-1))
                {
                    *ss=1;
                }
                for(int k=0;k<4;k++)
                {
                    int x=i+dx[k];
                    int y=j+dy[k];
                    if(x>=0 && x<grid.size() && y>=0 && y<grid[0].size() && 0==grid[x][y])
                    {
                        dfs(grid,flag,ss,x,y);
                    }
                }
            }
        }
    }
    
    int closedIsland(vector<vector<int>>& grid) 
    {
        int m=grid.size();
        int n=grid[0].size();
        vector<vector<int>> flag(m,vector<int>(n,0));
        int res=0;
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                int ss=0;
                int *tt=&ss;
                if(0==flag[i][j])
                {
                    dfs(grid,flag,tt,i,j);
                    if(0==ss && 2==grid[i][j])
                    {
                        res++;
                    }                    
                }
            }
        }
        return res;
    }
};

python

dx=[-1,1,0,0]
dy=[0,0,-1,1]

class Solution:
    def dfs(self,grid,flag,ss,i,j):
        if 0==flag[i][j]:
            flag[i][j]=1
            if 0==grid[i][j]:
                grid[i][j]=2
                if 0==i or i==(len(grid)-1) or 0==j or j==(len(grid[0])-1):
                    ss=1
                for k in range(4):
                    x=i+dx[k]
                    y=j+dy[k]
                    if x>=0 and x<len(grid) and y>=0 and y<len(grid[0]) and 0==grid[x][y]:
                        ss=self.dfs(grid,flag,ss,x,y)
        return ss
    
    def closedIsland(self, grid: List[List[int]]) -> int:
        m=len(grid)
        n=len(grid[0])
        flag=[[0 for j in range(n)] for i in range(m)]
        res=0
        for i in range(m):
            for j in range(n):
                ss=0
                if 0==flag[i][j]:
                    ss=self.dfs(grid,flag,ss,i,j)
                    if 0==ss and 2==grid[i][j]:
                        res+=1
        return res