Java实现 LeetCode 1254.统计封闭岛屿的数目（BFS/DFS）

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

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

BFS：
找到一个不在边界的为0的点，并判断它的上下左右有没有0的点，加入到队列中，如果与它连接的陆地含边界，则它不是封闭区域。

class Solution {
    int[][] dis = {{0,1},{0,-1},{1,0},{-1,0}};
    int m,n;
    public int closedIsland(int[][] grid) {
        m = grid.length;
        n = grid[0].length;
        int num = 0;
        for(int i = 1; i < m-1; i++) {
            for(int j = 1; j < n-1; j++) {
                if(grid[i][j] == 0) {
                    grid[i][j] = 1;
                    num += BFS(i,j,grid);
                }
            }
        }
        return num;
    }

    private int BFS(int x, int y, int[][] grid) {
        int num = 1;
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{x,y});
        while (!queue.isEmpty()) {
            int[] poll = queue.poll();
            for(int i = 0; i < 4; i++) {
                int nx = poll[0] + dis[i][0];
                int ny = poll[1] + dis[i][1];
                if(nx < 0 || ny < 0 || nx >= m || ny >= n || grid[nx][ny] == 1) continue;
                if((nx == 0 || ny == 0 || nx == m -1 || ny == n - 1 )&& grid[nx][ny] == 0) {
                    num = 0;
                }
                queue.add(new int[]{nx, ny});
                
                grid[nx][ny] = 1;
            }
        }
        return num;
    }
}

DFS：
这个方法有些啰嗦了，总的来说是用了两次DFS，一次找出地图上总共有多少个岛屿，第二次是从边界的为0的点开始找，与边界相连的岛屿有几块，与第一个dfs得到的总岛屿数相减，就得到封闭岛屿的数目。

class Solution {
    int m,n;
    int[][] vis;
    int[][] dis = {{0,1},{0,-1},{1,0},{-1,0}};
    public int closedIsland(int[][] grid) {
        //1.找总共有多少个岛屿
        m = grid.length;
        if(m == 0) return 0;
        n = grid[0].length;
        vis = new int[m][n];
        int num = 0;

        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(grid[i][j] == 0 && vis[i][j] == 0) {
                    vis[i][j] = 1;
                    dfs(i,j, grid);
                    num++;
                }
            }
        }
        
        //与边缘相邻的岛屿不被 1 包围
        vis = new int[m][n];
        for(int i = 0; i < m; i++) {
            if(grid[i][0] == 0 && vis[i][0] == 0) {
                vis[i][0] = 1;
                dfs(i,0,grid);
                num--;
            }
            if(grid[i][n-1] == 0 && vis[i][n-1] == 0) {
                vis[i][n-1] = 1;
                dfs(i, n-1, grid);
                num--;
            }
        }
        for(int j = 0; j < n; j++) {
            if(grid[0][j] == 0 && vis[0][j] == 0) {
                vis[0][j] = 1;
                dfs(0, j, grid);
                num--;
            } 
            if(grid[m-1][j] == 0 && vis[m-1][j] == 0) {
                vis[m-1][j] = 1;
                dfs(m-1,j,grid);
                num--;
            }
        }
        return num;
    }

    private void dfs(int x, int y, int[][] grid) {
        for(int i = 0; i < 4; i++) {
            int nx = x + dis[i][0];
            int ny = y + dis[i][1];
            if(nx < m && nx >= 0 && ny < n && ny >= 0 && vis[nx][ny] == 0 && grid[nx][ny] == 0) {
                vis[nx][ny] = 1;
                dfs(nx, ny, grid);
            }
        }
    
    }
}