题目：
给定一个由 1（陆地）和 0（水）组成的矩阵，你需要计算岛屿的数量。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。
输入描述
第一行包含两个整数 N, M，表示矩阵的行数和列数。
后续 N 行，每行包含 M 个数字，数字为 1 或者 0。
输出描述
输出一个整数，表示岛屿的数量。如果不存在岛屿，则输出 0。
输入示例
4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1
输出示例
3
提示信息
根据测试案例中所展示，岛屿数量共有 3 个，所以输出 3。
数据范围：
- 1 <= N, M <= 50
广度优先搜索理论基础：
广搜的搜索方式就适合于解决两个点之间的最短路径问题。
因为广搜是从起点出发，以起始点为中心一圈一圈进行搜索，一旦遇到终点，记录之前走过的节点就是一条最短路。
当然，也有一些问题是广搜 和 深搜都可以解决的，例如岛屿问题，这类问题的特征就是不涉及具体的遍历方式，只要能把相邻且相同属性的节点标记上就行。
广搜的过程
代码框架
这一圈一圈的搜索过程是怎么做到的，是放在什么容器里，才能这样去遍历。
其实，我们仅仅需要一个容器，能保存我们要遍历过的元素就可以，那么用队列，还是用栈，甚至用数组，都是可以的。
用队列的话，就是保证每一圈都是一个方向去转，例如统一顺时针或者逆时针。
因为队列是先进先出，加入元素和弹出元素的顺序是没有改变的。
如果用栈的话，就是第一圈顺时针遍历，第二圈逆时针遍历，第三圈有顺时针遍历。
因为栈是先进后出，加入元素和弹出元素的顺序改变了。
那么广搜需要注意 转圈搜索的顺序吗？ 不需要！
所以用队列，还是用栈都是可以的，但大家都习惯用队列了。
下面给出广搜代码模板，该模板针对的就是，上面的四方格的地图广搜一圈一圈的搜索过程： （详细注释）
// dir[4][2] 是一个二维数组，其中：
// 第一维（dir[i]）表示方向，共有 4 个方向。
// 第二维（dir[i][0] 和 dir[i][1]）表示在每个方向上的 x 和 y 的变化值。
// 对于{1, 0}，表示右方向。x 增加，表示向右移动。：
// dir[i][0] = 1：表示 x 坐标的变化值。
// dir[i][1] = 0：表示 y 坐标的变化值。
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 表示四个方向
// grid 是地图，也就是一个二维数组
// visited标记访问过的节点，不要重复访问
// x,y 表示开始搜索节点的下标
void bfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y) {
queue<pair<int, int>> que; // 定义队列
que.push({x, y}); // 起始节点加入队列
visited[x][y] = true; // 只要加入队列，立刻标记为访问过的节点
while(!que.empty()) { // 开始遍历队列里的元素
pair<int ,int> cur = que.front(); que.pop(); // 从队列取元素
int curx = cur.first;
int cury = cur.second; // 当前节点坐标
for (int i = 0; i < 4; i++) { // 开始想当前节点的四个方向左右上下去遍历
int nextx = curx + dir[i][0];
int nexty = cury + dir[i][1]; // 获取周边四个方向的坐标
if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue; // 坐标越界了，直接跳过
if (!visited[nextx][nexty]) { // 如果节点没被访问过
que.push({nextx, nexty}); // 队列添加该节点为下一轮要遍历的节点
visited[nextx][nexty] = true; // 只要加入队列立刻标记，避免重复访问
}
}
}
}
思路
注意题目中每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
也就是说斜角度链接是不算了， 例如示例二，是三个岛屿，如图：
这道题题目是 DFS，BFS，并查集，基础题目。
本题思路:遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。
再遇到标记过的陆地节点和海洋节点的时候直接跳过。 这样计数器就是最终岛屿的数量。
那么如果把节点陆地所能遍历到的陆地都标记上呢，就可以使用 DFS，BFS或者并查集。
广度优先搜索
不少同学用广搜做这道题目的时候，超时了。 这里有一个广搜中很重要的细节：
根本原因是只要 加入队列就代表 走过，就需要标记，而不是从队列拿出来的时候再去标记走过。
很多同学可能感觉这有区别吗？
如果从队列拿出节点，再去标记这个节点走过，就会发生下图所示的结果，会导致很多节点重复加入队列。
代码：
#include<iostream>
#include<vector>
#include<queue>
using namespace std;
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void bfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y){
queue<pair<int, int>> que;
que.push({x, y}); // 将点放入队列中
// 加入队列后标记已访问
// 这里包括下面标记访问的地方与A*中不同，因为这里不需要评估节点的价值，可以立即标记已访问
// 而A*中需要从OpenList中取出进行评估时，才标记为已访问，不然将会缺少这些节点扩展
visited[x][y] = true;
while(!que.empty()){
pair<int, int> cur = que.front(); que.pop(); // 从队列中取出第一个节点作为当前节点
int curX = cur.first;
int curY = cur.second;
for(int i = 0; i < 4; i++){
int nextX = curX + dir[i][0];
int nextY = curY + dir[i][1];
// 超出方格界限，跳过
if(nextX < 0 || nextX >= grid.size() || nextY < 0 || nextY >= grid[0].size()) continue;
if(!visited[nextX][nextY] && grid[nextX][nextY] == 1){
que.push({nextX, nextY}); // 注意这里将新节点放入队列中
visited[nextX][nextY] = true; // 只要加入队列立刻标记
}
}
}
}
int main(){
int n, m;
cin >> n >> m;
vector<vector<int>> grid(n, vector<int>(m, 0));
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
cin >> grid[i][j];
}
}
vector<vector<bool>> visited(n, vector<bool>(m, false));
int result = 0;
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
if(!visited[i][j] && grid[i][j] == 1){
result++; // 遇到没访问的陆地， +1
bfs(grid, visited, i, j); // 将与其连接的陆地都标记上true
}
}
}
cout << result << endl;
return 0;
}
总结：
广搜的搜索方式就适合于解决两个点之间的最短路径问题。
因为广搜是从起点出发，以起始点为中心一圈一圈进行搜索，一旦遇到终点，记录之前走过的节点就是一条最短路。
当然，也有一些问题是广搜 和 深搜都可以解决的，例如岛屿问题，这类问题的特征就是不涉及具体的遍历方式，只要能把相邻且相同属性的节点标记上就行。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
