BFS广度优先

个人最喜欢的算法之一，这是一种犹如洪水般的算法，O（n）的时间复杂度。

##红色不可流动 ，橙色可流动，黄色所在点，蓝色在队列里。

就像洪水一样，当你得到某个位置时候，开始判断它的上下左右是否可流动并判断有没有流过。

开始判断它的上下左右是否可流动并判断有没有流过，若可以放入上下左右可流动的位置。

接下来把queue中的位置取出来，开始判断它的上下左右是否可流动。

开始判断它的上下左右是否可流动并判断有没有流过，若可以放入上下左右可流动的位置。

接下来把queue中的位置取出来，开始判断它的上下左右是否可流动。

开始判断它的上下左右是否可流动并判断有没有流过，若可以放入上下左右可流动的位置。

接下来把queue中的位置取出来，开始判断它的上下左右是否可流动。

开始判断它的上下左右是否可流动并判断有没有流过，若可以放入上下左右可流动的位置。

接下来把queue中的位置取出来，开始判断它的上下左右是否可流动。

。。。。。。。。。。。。

直到队列空了，放不了东西了。一起结束了

模板 4方向制 ：

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

using namespace std;

// 定义方向数组，表示上下左右四个方向
int dx[4] = { -1, 1, 0, 0 };
int dy[4] = { 0, 0, -1, 1 };

// 检查坐标 (x, y) 是否在网格范围内且是可通行的
bool isValid(int x, int y, int n, int m, vector<vector<int>>& grid, vector<vector<bool>>& visited) {
    return (x >= 0 && x < n && y >= 0 && y < m && grid[x][y] == 1 && !visited[x][y]);
}

void bfs(int startX, int startY, int n, int m, vector<vector<int>>& grid) {
    queue<pair<int, int>> q;
    vector<vector<bool>> visited(n, vector<bool>(m, false));

    q.push({startX, startY});
    visited[startX][startY] = true;

    while (!q.empty()) {
        auto [x, y] = q.front();
        q.pop();

        // 处理当前节点 (x, y)
        cout << "Visiting node: (" << x << ", " << y << ")" << endl;

        // 遍历四个方向
        for (int i = 0; i < 4; ++i) {
            int newX = x + dx[i];
            int newY = y + dy[i];

            if (isValid(newX, newY, n, m, grid, visited)) {
                q.push({newX, newY});
                visited[newX][newY] = true;
            }
        }
    }
}

int main() {
    int n = 5, m = 5; // 网格大小
    vector<vector<int>> grid = {
        {1, 0, 1, 1, 1},
        {1, 1, 0, 1, 0},
        {0, 1, 1, 0, 1},
        {1, 0, 1, 1, 1},
        {1, 1, 1, 0, 1}
    };

    int startX = 0, startY = 0; // 起始点
    bfs(startX, startY, n, m, grid);

    return 0;
}