岛屿数量

Posted 2021-03-04 xiao--ge

给定一个由 ‘1‘（陆地）和 ‘0‘（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。

示例1：

输入:
11110
11010
11000
00000

输出: 1

示例2：

输入:
11000
11000
00100
00011

输出: 3

解题思路：

本题是Leetcode中的一道BFS算法题，采用BFS算法，遍历整个数组，遇到陆地时将其放入队列中，遍历完与其向相连的所有大陆，并将遍历过的陆地清除（置为‘0’）。

C++代码：

 1 class Solution {
 2 public:
 3     int numIslands(vector<vector<char>>& grid) {
 4         if(grid.empty())return 0;
 5         queue<pair<int,int>> que;
 6         int result = 0;
 7         int que_i=0,que_j=0;
 8         int grid_list_size = grid.size();
 9         int grid_line_size = grid[0].size();
10         //寻找一个陆地作为起始点
11         for(int i=0;i<grid_list_size;i++)
12         {
13             for(int j=0;j<grid_line_size;j++)
14             {
15                 if(grid[i][j]==‘1‘)
16                 {
17                     que.push(pair<int,int>(i,j));
18                     grid[i][j] = ‘0‘;
19                     result++;
20                     //遍历完整块岛屿
21                     while(!que.empty())
22                     {
23                         que_i = que.front().first;
24                         que_j = que.front().second;
25                         que.pop();
26                         //上下判断
27                         for(int a=-1;a<=1;a+=2)
28                         {
29                             //边界限定
30                             if(que_i+a>=0&&que_i+a<grid_list_size)
31                             {
32                                 if(grid[que_i+a][que_j]==‘1‘)
33                                 {
34                                     que.push(pair<int,int>(que_i+a,que_j));
35                                     grid[que_i+a][que_j] =‘0‘;
36                                 }
37                             }
38                         }
39                         //左右判断
40                         for(int a=-1;a<=1;a+=2)
41                         {
42                             //边界限定
43                             if(que_j+a>=0&&que_j+a<grid_line_size)
44                             {
45                                 if(grid[que_i][que_j+a]==‘1‘)
46                                 {
47                                     que.push(pair<int,int>(que_i,que_j+a));
48                                     grid[que_i][que_j+a] =‘0‘;
49                                 }
50                             }
51                         }
52                     }
53                 }
54             }
55         }
56         return result;
57     }
58 };