C++的数据结构(十四）：图的广度优先遍历（BFS）

        在数据结构和算法中，图的广度优先遍历（BFS）是一种常用的搜索算法，它按照广度优先搜索的策略访问图中的节点。常用于解决图的搜索问题等。在C++中，我们可以使用队列（Queue）来实现广度优先遍历。

        下面，我们将以力扣（LeetCode）上的一道题目为例，来展示C++中图的广度优先遍历的应用。题目描述：给定一个由 '1'（陆地）和 '0'（水）组成的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设整个网格都被水包围。       

示例：
        输入:
                11110
                11010
                11000
                00000

        输出: 1
        解释：只有一个由陆地组成的岛屿。

         为了解决这个问题，我们可以使用广度优先遍历。具体思路是，遍历整个网格，对于每个遇到的陆地（值为1的单元格），我们将其视为一个岛屿的起点，并使用BFS遍历与其相连的所有陆地，将它们标记为已访问（例如，将其值设为0）。这样，每次遍历完一个岛屿的所有陆地后，岛屿的数量就增加1。代码如下。

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

void bfs(vector<vector<char>>& grid, int i, int j) {
    int rows = grid.size();
    int cols = grid[0].size();
    
    // 四个方向的偏移量
    int dx[] = {-1, 1, 0, 0};
    int dy[] = {0, 0, -1, 1};
    
    // 标记当前陆地为已访问
    grid[i][j] = '0';
    
    queue<pair<int, int>> q;
    q.push({i, j});
    
    while (!q.empty()) {
        int currX = q.front().first;
        int currY = q.front().second;
        q.pop();
        
        // 遍历当前节点的四个相邻节点
        for (int k = 0; k < 4; ++k) {
            int nextX = currX + dx[k];
            int nextY = currY + dy[k];
            
            // 检查相邻节点是否在网格范围内且为陆地
            if (nextX >= 0 && nextX < rows && nextY >= 0 && nextY < cols && grid[nextX][nextY] == '1') {
                q.push({nextX, nextY});
                grid[nextX][nextY] = '0'; // 标记为已访问
            }
        }
    }
}

int numIslands(vector<vector<char>>& grid) {
    int rows = grid.size();
    if (rows == 0) return 0;
    int cols = grid[0].size();
    int count = 0;
    
    // 遍历整个网格
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            if (grid[i][j] == '1') {
                // 对每个岛屿进行BFS遍历
                bfs(grid, i, j);
                ++count; // 岛屿数量加1
            }
        }
    }
    
    return count;
}

int main() {
    vector<vector<char>> grid = {
        {'1', '1', '1', '1', '0'},
        {'1', '1', '0', '1', '0'},
        {'1', '1', '0', '0', '0'},
        {'0', '0', '0', '0', '0'}
    };
    
    int allnumIsland = numIslands(grid);
    cout << "岛屿数量: " << numIslands << endl;
    
    return 0;
}

        在上述代码中，我们首先定义了一个`bfs`函数，它负责以当前陆地坐标为起点进行广度优先遍历，并将所有相连的陆地都标记为已访问。然后，我们在`numIslands`函数中遍历整个网格，每当遇到一个陆地时，就调用`bfs`函数，同时岛屿计数加一。

        最后，在`main`函数中，我们定义了一个二维字符数组来表示输入的网格，并调用`numIslands`函数来计算岛屿数量。程序运行后，将输出网格中岛屿的数量。

        通过这段代码，我们可以看到C++中图的广度优先遍历在解决岛屿数量问题时的应用。广度优先遍历（BFS）是一种用于遍历或搜索树或图的算法。在图中，BFS从根（或任意节点）开始，探索最近的邻居节点，然后对每个邻居节点执行相同的操作，如此循环直至访问所有可达节点。在岛屿数量问题中，BFS用于标记和计数与起始陆地相连的整片陆地。