LeetCode 2203. 得到要求路径的最小带权子图（dijkstra算法）

---

题目描述

• 2203. 得到要求路径的最小带权子图

解题思路：三次最短路

• 从 ${\text{src}}_1$ 到 $\text{dest}$ 有唯一的一条简单路径，记为 $X$

• 从 ${\text{src}}_2$ 到 $\text{dest}$ 有唯一的一条简单路径，记为 $Y$

假设 $X$ 上第一个与 $Y$ 共有的节点为 $c$，显然这样的 $c$ 是一定存在的，因为 $\text{dest}$ 就是 $X$ 和 $Y$ 的一个共有节点（但可能存在更早的共有节点）。因此，整个子图可以看成是三部分的并集：

• 从 ${\text{src}}_1$ 到 $c$ 的一条简单路径

• 从 ${\text{src}}_2$ 到 $c$ 的一条简单路径

• 从 $c$ 到 $\text{dest}$ 的一条简单路径

此时子图的边权和即为这三部分的边权和之和，即子图呈现「Y 型」。

算法流程：

• 使用两次 $\text{Dijkstra}$ 算法计算出以 ${\text{src}}_1$ 为出发点和以 ${\text{src}}_2$ 为出发点，到所有节点的最短路径长度
• 对于「从 $c$ 到 $\text{dest}$」这一部分，可以将原图中的所有边反向，这样就变成了「从 $\text{dest}$ 到 $c$」。就可以使用 $\text{Dijkstra}$ 算法计算出以 $\text{dest}$ 为出发点，到所有节点的最短路径长度
• 在得到了所有需要的最短路径的长度之后，枚举 $c$ 得出答案

class Solution {
    public long minimumWeight(int n, int[][] edges, int src1, int src2, int dest) {
        // 建图 正向图 + 反向图
        List<int[]>[] g = new List[n], rg = new List[n];
        Arrays.setAll(g, e -> new ArrayList<int[]>());
        Arrays.setAll(rg, e -> new ArrayList<int[]>());
        for (int[] e : edges) {
            int x = e[0], y = e[1], weight = e[2];
            g[x].add(new int[]{y, weight});
            rg[y].add(new int[]{x, weight});
        }
        // 3次dijkstra
        long[] dist1 = dijkstra(g, src1);
        long[] dist2 = dijkstra(g, src2);
        long[] dist3 = dijkstra(rg, dest);
        // 枚举 c
        long ans = Long.MAX_VALUE/3;
        for (int i = 0; i < n; i++) {
            if (dist1[i] == Long.MAX_VALUE/3 || dist2[i] == Long.MAX_VALUE/3 || dist3[i] == Long.MAX_VALUE/3) {
                continue ;
            }
            ans = Math.min(ans, dist1[i] + dist2[i] + dist3[i]);
        }
        return ans >= Long.MAX_VALUE/3 ? -1 : ans;
    }

    // 计算点 start 到各点的最短距离
    private long[] dijkstra(List<int[]>[] g, int start) {
        // dist[x] = y 代表从「源点/起点」到 x 的最短距离为 y
        long[] dist = new long[g.length];
        // 起始先将所有的点标记为「距离为正无穷」
        Arrays.fill(dist, Long.MAX_VALUE / 3);
        // 只有起点最短距离为 0
        dist[start] = 0;
        // 小根堆 
        // 以 (到起点的距离，点编号) 进行存储，优先弹出「最短距离」较小的点
        PriorityQueue<long[]> pq = new PriorityQueue<long[]>((a, b) -> Long.compare(a[0], b[0]));
        pq.offer(new long[]{0l, start});
        while (!pq.isEmpty()) {
            long[] p = pq.poll();
            long weight = p[0];
            int x = (int) p[1];
            if (weight > dist[x]) {
                continue ;
            }
            // 更新其他点的「最短距离」
            for (int[] e : g[x]) {
                int y = e[0];
                long d = dist[x] + e[1];
                if (d < dist[y]) {
                    dist[y] = d;
                    pq.offer(new long[]{d, y});
                }
            }
        }
        return dist;
    }
}

• 时间复杂度：$O(n+m\log m)$，其中 $m$ 是数组 $\text{edges}$ 的长度

• 空间复杂度：$O(m)$，即为存储图和反向图的邻接表需要使用的空间

Reference

• 得到要求路径的最小带权子图