【笔记】力扣 3243. 新增道路查询后的最短距离 I——BFS

3243. 新增道路查询后的最短距离 I

中等

给你一个整数 n 和一个二维整数数组 queries。

有 n 个城市，编号从 0 到 n - 1。初始时，每个城市 i 都有一条单向道路通往城市 i + 1（ 0 <= i < n - 1）。

queries[i] = [ui, vi] 表示新建一条从城市 ui 到城市 vi 的单向道路。每次查询后，你需要找到从城市 0 到城市 n - 1 的最短路径的长度。

返回一个数组 answer，对于范围 [0, queries.length - 1] 中的每个 i，answer[i] 是处理完前 i + 1 个查询后，从城市 0 到城市 n - 1 的最短路径的长度。

示例 1：

输入： n = 5, queries = [[2, 4], [0, 2], [0, 4]]

输出： [3, 2, 1]

解释：

新增一条从 2 到 4 的道路后，从 0 到 4 的最短路径长度为 3。

新增一条从 0 到 2 的道路后，从 0 到 4 的最短路径长度为 2。

新增一条从 0 到 4 的道路后，从 0 到 4 的最短路径长度为 1。

示例 2：

输入： n = 4, queries = [[0, 3], [0, 2]]

输出： [1, 1]

解释：

新增一条从 0 到 3 的道路后，从 0 到 3 的最短路径长度为 1。

新增一条从 0 到 2 的道路后，从 0 到 3 的最短路径长度仍为 1。

提示：

• 3 <= n <= 500
• 1 <= queries.length <= 500
• queries[i].length == 2
• 0 <= queries[i][0] < queries[i][1] < n
• 1 < queries[i][1] - queries[i][0]
• 查询中没有重复的道路。

题解

#include <vector>
#include <queue>

class Solution {
public:
    // 用于存储每次查询后从城市 0 到城市 n - 1 的最短路径长度
    std::vector<int> res;
    // 邻接表，用于表示图的结构，neighbors[i] 存储从城市 i 出发可以到达的所有城市
    std::vector<std::vector<int>> neighbors;

    // 广度优先搜索函数，用于计算从城市 0 到城市 n - 1 的最短路径长度
    int bfs(int n) {
        // 距离数组，dist[i] 表示从城市 0 到城市 i 的最短距离，初始值 -1 表示未访问
        std::vector<int> dist(n, -1);
        // 队列，用于 BFS 过程中存储待访问的节点
        std::queue<int> q;
        // 将起点城市 0 加入队列
        q.push(0);
        // 起点城市 0 到自身的距离为 0
        dist[0] = 0;

        // 当队列不为空时，继续进行 BFS 搜索
        while (!q.empty()) {
            // 取出队列的队首元素
            int node = q.front();
            // 将队首元素从队列中移除
            q.pop();
            // 遍历当前节点 node 的所有相邻节点
            for (int x : neighbors[node]) {
                // 如果相邻节点 x 还未被访问
                if (dist[x] == -1) {
                    // 更新相邻节点 x 到起点的最短距离为当前节点 node 到起点的距离加 1
                    dist[x] = dist[node] + 1;
                    // 将相邻节点 x 加入队列，以便后续继续搜索
                    q.push(x);
                }
            }
        }
        // 返回从城市 0 到城市 n - 1 的最短距离
        return dist[n - 1];
    }

    // 处理所有查询操作，并记录每次查询后从城市 0 到城市 n - 1 的最短路径长度
    std::vector<int> shortestDistanceAfterQueries(int n, std::vector<std::vector<int>>& queries) {
        // 调整邻接表的大小为 n
        neighbors.resize(n);
        // 初始化邻接表，将每个城市 i 到城市 i + 1 的单向道路加入邻接表
        for (int i = 0; i < n - 1; i++) {
            neighbors[i].push_back(i + 1);
        }

        // 遍历所有查询操作
        for (int i = 0; i < queries.size(); i++) {
            // 对于每个查询 [u, v]，将从城市 u 到城市 v 的单向道路加入邻接表
            neighbors[queries[i][0]].push_back(queries[i][1]);
            // 调用 bfs 函数计算当前图状态下从城市 0 到城市 n - 1 的最短路径长度
            // 并将结果添加到 res 向量中
            res.push_back(bfs(n));
        }
        // 返回存储所有查询结果的向量 res
        return res;
    }
};