Leetcode 1254. 统计封闭岛屿的数目

题目：

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

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

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

　　请返回封闭岛屿的数目。　

　　　

　　输入：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 区域包围）。

 分析：

　　1.对于边界而言，即使其为陆地，也至少存在一个变不能临近水域，所以不可能构成孤岛；

　　2.对于边界上的陆地而言，其相邻的陆地，肯定也构不成孤岛，即所能到达的陆地，均不可以。

　　3.对于剩余区域的陆地X，其所能到达的陆地Y，能够和X构成同一片岛屿。

 方案：（参考别人的https://leetcode-cn.com/problems/number-of-closed-islands/solution/yi-ti-kan-tou-dfs-he-dfs-by-xiao-xiao-suan-fa/）

　　直接从边界的陆地开始DFS或BFS遍历，只要边界陆地能遍历到的地方就不是封闭岛屿，同时我们也要将遍历过得点置为1，表示该位置已经遍历过。最后，里面为0的位置都是属于封闭岛屿的陆地了。

 代码部分：

 #include <iostream>
 #include <vector>
 using namespace std;
 
 void dfs(int x, int y, vector<vector<int>>& grid) {
     int xlen = grid.size();  //行
     int ylen = grid[].size();  //列
     if (x >= xlen || y >= ylen || x <  || y <  || grid[x][y] == ) {  //越界或者为水域，直接返回
         return;
     }
     grid[x][y] = ;  //标记已遍历过的节点
     int vx[] = { , , , - };   //记录四个方向，如vx[0],vy[0]，即横坐标不变，纵坐标加1，向上移动一步
     int vy[] = { , , -,  };
     for (int i = ; i < ; i++)
     {
         dfs(x + vx[i],y + vy[i],grid); //遍历剩余四个方向
     }
 }
 
 void printGrid(vector<vector<int> > grid) {  //打印二维矩阵
     for (int i = ; i < grid.size(); i++)
     {
         for (int j = ; j < grid[].size(); j++)
         {
             cout << grid[i][j] << " ";
         }
         cout << endl;
     }
 }
 
 int closedIsland(vector<vector<int> > &grid)
 {
     int result = ;
     int y = grid.size();  //一共有多少行
     int x = grid[].size();
     int i, j;
     //从边界往里遍历，凡是能到达的所有陆地，均不能构成闭合岛屿
     for (i = ; i < y; i++) {
         for (j= ; j < x; j++)
         {
             if (i ==  || j ==  || i == y -  || j == x - ) {
                 dfs(i, j, grid);
             }
         }
     }
     cout << "\n边界处理完成后的结果：" << endl;
     printGrid(grid);
     //继续遍历，剩余结点中，某个陆地x能到达的所有区域，构成一个孤岛，统计有多少个这样的x
     for (i = ; i < grid.size(); i++)
     {
         for (j= ; j < grid[].size(); j++)
         {
             if (grid[i][j] == )  //起点，遍历结束后，所有可到达的点被标记为水域，即产生一个孤岛
             {
                 result++;
                 dfs(i,j,grid);
             }
         }
     }
     return result;
 }
 
 int main() {
     vector<vector<int> > grid;
     //输入二维矩阵
     int m, n;
     cin >> m >> n;
     vector<int> temp(n);  //结束临时一维数组构建二维数组
     grid.resize(m,temp);  //二维数组大小初始化（注意用法）
     int i, j;
     for (i = ; i < m; i++)
     {
         for (j = ; j < n;j++)
         {
             cin >> grid[i][j];  //输入二维数组元素
         }
     }
 
     cout << "\n孤岛计算结果：" << closedIsland(grid) << endl;  //输出计算结果
 
 }

运行结果：

　　

分析：

　　

　　第一步是将1,2两块区域排除，毕竟它们处于边界，不可能成为孤岛区域

　　第二步是找出3,4,两块区域，比如第4块，想从左上角开始深度优先遍历（当然广度也可以），岂能到达的所有陆地领域都是联通的，共同构成一个孤岛，因此，ret+1；

　　最后，返回结果！