计数孤岛（DFS和BFS解决）

广度优先搜索（BFS）和岛屿问题

深度优先搜索：就这某一个方向去一直搜索，直到这个方向无法搜索了，回溯，换下一个方向去搜索

广度优先搜索

以起点为中心，向四周扩散的方式。是一种按层来遍历的搜索算法。

核心思想为：先搜离起点近的，在搜远的。

先把"同一层"的节点全部处理完，才会进入下一层

常用队列实现，队列先进先出，可以保证一层一层处理。（不用栈的原因：队列可以保证搜索时方向的一致性，栈无法保证总是顺时针或逆时针处理）

广度优先搜索代码框架

cpp 复制代码

int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 表示四个方向
// grid 是地图，也就是一个二维数组
// visited标记访问过的节点，不要重复访问
// x,y 表示开始搜索节点的下标
void bfs(vector<vector<char>>& 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函数，即当我们找到了一个未被访问过的孤岛时，我们要使用DFS函数去标记它周围的陆地，并对该陆地进行dfs搜索，保证该岛屿被标记彻底。（这个函数是没有return语句的，当周围为水域或该岛屿已被标记过时，他会自动一层一层结束for循环）（注意剪枝优化，若超出当前研究的范围，直接进行跳过当前循环，进入下一次深搜）

在主函数中，我们先将所有孤岛标记为未访问过，然后开始遍历所有岛屿。如果他是陆地且未被访问过，我们就将岛屿该岛屿标记为已访问；并将岛屿数量加一，然后调用深搜函数，将其周围相邻的陆地标记为已访问过。

方法一对应的完整代码

cpp 复制代码

#include <iostream>
#include <vector>
using namespace std;

int dir[4][2]={0,1,1,0,-1,0,0,-1};
void dfs(const vector<vector<int>>& grid,vector<vector<bool>>& visited,int x,int y){
    for(int i=0;i<4;i++){
        int nextx=x+dir[i][0];
        int nexty=y+dir[i][1];
        if(nextx<0||nextx>=grid.size()||nexty<0||nexty>=grid[0].size())
        continue;
        if(!visited[nextx][nexty]&&grid[nextx][nexty]==1){
            visited[nextx][nexty]=true;
            dfs(grid,visited,nextx,nexty);
        }
    }
}

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){
                visited[i][j]=true;
                result++;
                dfs(grid,visited,i,j);
            }
        }
    }
    cout<<result<<endl;
}

方法二：广搜解决

BFS函数部分：先将当前传入的节点入队，然后一个while循环，只要队列不为空，while循环就继续（为什么只要队列不为空就继续循环？因为队列里面的元素都是与该节点相邻且未被访问过的陆地）while循环内部：就是把当前陆地相邻且未被访问过的陆地部分标记并加入队列。

和DFS一样，越界部分记得优化。

main函数部分和深搜法类似。

方法二对应的完整代码

cpp 复制代码

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void bfs(const 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] && 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;
}