🚍 Queue – Hàng đợi FIFO

#include 
using namespace std;

int main() {
    int n, m, source;
    cin >> n >> m >> source;

    vector> graph(n + 1);

    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;

        graph[u].push_back(v);
        graph[v].push_back(u);
    }

    vector distance(n + 1, -1);
    vector parent(n + 1, -1);
    queue q;

    distance[source] = 0;
    q.push(source);

    while (!q.empty()) {
        int u = q.front();
        q.pop();

        for (int v : graph[u]) {
            if (distance[v] != -1) continue;

            distance[v] = distance[u] + 1;
            parent[v] = u;
            q.push(v);
        }
    }
}

#include 
using namespace std;

int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};

int main() {
    int n, m;
    cin >> n >> m;

    vector grid(n);
    for (string &row : grid) cin >> row;

    vector> distance(
        n,
        vector(m, -1)
    );

    queue> q;

    if (grid[0][0] != '#') {
        distance[0][0] = 0;
        q.push({0, 0});
    }

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

        for (int direction = 0; direction < 4; direction++) {
            int nx = x + dx[direction];
            int ny = y + dy[direction];

            if (nx < 0 || nx >= n || ny < 0 || ny >= m) {
                continue;
            }

            if (grid[nx][ny] == '#') continue;
            if (distance[nx][ny] != -1) continue;

            distance[nx][ny] = distance[x][y] + 1;
            q.push({nx, ny});
        }
    }

    cout << distance[n - 1][m - 1];
}

queue> q;
vector> distance(n, vector(m, -1));

for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        if (grid[i][j] == 'S') {
            distance[i][j] = 0;
            q.push({i, j});
        }
    }
}

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

    for (int direction = 0; direction < 4; direction++) {
        int nx = x + dx[direction];
        int ny = y + dy[direction];

        if (!inside(nx, ny)) continue;
        if (grid[nx][ny] == '#') continue;
        if (distance[nx][ny] != -1) continue;

        distance[nx][ny] = distance[x][y] + 1;
        q.push({nx, ny});
    }
}

from collections import deque

def bfs(graph, source):
    distance = [-1] * len(graph)
    queue = deque([source])

    distance[source] = 0

    while queue:
        vertex = queue.popleft()

        for neighbor in graph[vertex]:
            if distance[neighbor] != -1:
                continue

            distance[neighbor] = distance[vertex] + 1
            queue.append(neighbor)

    return distance