题目描述：

给你一个整数 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 的最短路径的长度。

示例 ：

输入： 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。

代码实现：

class Solution {
    public int[] shortestDistanceAfterQueries(int n, int[][] queries) {
        // 初始化答案列表
        List<Integer> answer = new ArrayList<>();
        // 初始化图：表示当前点能到达其他位置的集合
        List<List<Integer>> graph = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            graph.add(new ArrayList<>());// 添加0到n-1个城市
        }
        // 添加初始的单向边
        for (int i = 0; i < n - 1; i++) {
            graph.get(i).add(i + 1);// 表示第i个城市可以到达第i+1个城市
        }
        // 处理每一个查询
        for (int[] query : queries) {
            int u = query[0];// 起点
            int v = query[1];// 终点
            // 添加新建的单向边
            graph.get(u).add(v);
            // 使用BFS计算从城市0到城市n-1的最短路径长度
            answer.add(bfsShortestPath(graph, n));
        }
        // 将列表转换为数组
        int[] res = new int[answer.size()];
        for (int i = 0; i < answer.size(); i++) {
            res[i] = answer.get(i);
        }
        return res;
    }

    int bfsShortestPath(List<List<Integer>> graph, int n) {
        // 队列用于BFS
        Queue<Integer> queue = new LinkedList<>();
        // 距离数组用于记录从0到其他节点的距离
        int[] dist = new int[n];
        Arrays.fill(dist, Integer.MAX_VALUE);// 将dist数组所有元素初始化为Integer中的最大值
        dist[0] = 0;// 初始化0到第0个城市，距离为0
        queue.offer(0);// 入队
        // 从0开始广度优先搜索队列内元素
        while (!queue.isEmpty()) {// 当队列为空时，跳出循环
            int current = queue.poll();// 出队当前队头元素
            for (int neighbor : graph.get(current)) {// 遍历当前队头元素在图上可达邻点
                if (dist[neighbor] == Integer.MAX_VALUE) {// 如果邻点为初始值时
                    dist[neighbor] = dist[current] + 1;// 更新最短距离
                    queue.offer(neighbor);// 并且让邻点入队
                }
            }
        }
        return dist[n - 1];// 返回dist数组中尾部元素，即当前路径中0到n-1的最短距离
    }
}