统计封闭岛屿的数目

有一个二维矩阵 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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-closed-islands
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法一：就是从表格中的0开始找，遇到1就加1，遇到边界就加0；然后取最小

class Solution {
private:
    int row, col;
    int res;
    int dir[4][2] = {{0,1},{1,0},{-1,0},{0,-1}};
public:
    
    int dfs(vector<vector<int>>& grid, int i,int j){
        if(i<0||i>=row||j<0||j>=col){
            return 0;
        }
        if(grid[i][j] == 1){
            return 1;
        }
        grid[i][j] = 1;
        int tmp = 1;
        for(int k=0;k<4;k++){
            int xx = i+dir[k][0];
            int yy = j+dir[k][1];
            tmp = min(tmp, dfs(grid,xx,yy));
            cout<<tmp<<endl;
        }
        return tmp;
    }
    int closedIsland(vector<vector<int>>& grid) {
        if(grid.empty()||grid[0].empty()){
            return 0;
        }
        row = grid.size();
        col = grid[0].size();
        res = 0;
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                if(grid[i][j]==0){
                    res += dfs(grid,i,j);
                }
               
            }
        }
        return res;
        
    }
};

为什么要使用min()呢？因为只要有一个返回0，就说明有一个方向走出了边界，那该位置所在岛屿就不是封闭岛屿，即使其它三个方向都返回1.

方法二：就是先填充边界的0和边界相关的链接部分0，再统计内部分块的部分；

class Solution {
private:
    int row, col;
    int res=0;
    int dir[4][2] = {{0,1},{1,0},{-1,0},{0,-1}};
public:
    /***这里面就是先遍历四个边，将边里面的0dfs成1，然后在遍历里面***/
    void dfs(vector<vector<int>>& grid, int i,int j){
        if(i<0||i>=row||j<0||j>=col||grid[i][j]!=0){
            return;
        }
        grid[i][j] = 1;
        for(int k=0;k<4;k++){
            int xx = i+dir[k][0];
            int yy = j+dir[k][1];
            //cout<<xx<<'\t'<<yy<<endl;
            dfs(grid, xx,yy);
        }
    }
    int closedIsland(vector<vector<int>>& grid) {
        if(grid.empty()||grid[0].empty()){
            return 0;
        }
        row = grid.size();
        col = grid[0].size();
        for(int i=0;i<col;i++){
            dfs(grid,0,i);
            dfs(grid,row-1,i);
        }
        for(int i=0;i<row;i++){
            dfs(grid, i,0);
            dfs(grid,i,col-1);
        }
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                if(grid[i][j]==0){
                    dfs(grid,i,j);
                    res++;
                }
            }
        }
        return res;
        
    }
};

这道题思路不难，但要注意编程时变量的应用；