笔记-LeetCode 743: 网络延迟时间 (Dijkstra vs BFS)

题目描述

给你一个由 n 个节点（下标从 0 开始）组成的无向加权图，该图由一个描述边的列表组成，其中 edges[i] = [a, b] 表示连接节点 a 和 b 的一条无向边，且该边遍历成功的概率为 succProb[i]。

指定两个节点分别作为起点 start 和终点 end，请你找出从起点到终点成功概率最大的路径，并返回其成功概率。

如果不存在从 start 到 end 的路径，请返回 0。只要答案与标准答案的误差不超过 1e-5，就会被视作正确答案。

---

代码模板（Dijkstra 最短路径算法）

import java.util.*;

class Solution {
    public double maxProbability(int n, int[][] edges, double[] succProb, int start, int end) {
        // 1. 构建邻接表，使用 HashMap 存储每个节点的邻接点和对应的概率
        Map<Integer, List<double[]>> graph = new HashMap<>();
        for (int i = 0; i < edges.length; i++) {
            int a = edges[i][0], b = edges[i][1];
            double prob = succProb[i];
            graph.computeIfAbsent(a, x -> new ArrayList<>()).add(new double[]{b, prob});
            graph.computeIfAbsent(b, x -> new ArrayList<>()).add(new double[]{a, prob});
        }

        // 2. 使用最大堆（优先队列），保证每次取出当前概率最大的路径
        PriorityQueue<double[]> pq = new PriorityQueue<>((a, b) -> Double.compare(b[1], a[1]));
        pq.offer(new double[]{start, 1.0});
        
        // 3. 记录从 start 到各个节点的最大概率
        Map<Integer, Double> probMap = new HashMap<>();
        probMap.put(start, 1.0);
        
        // 4. Dijkstra 变种（最大概率路径）
        while (!pq.isEmpty()) {
            double[] curr = pq.poll();
            int node = (int) curr[0];
            double prob = curr[1];
            
            // 如果到达终点，直接返回最大概率
            if (node == end) return prob;
            
            for (double[] neighbor : graph.getOrDefault(node, new ArrayList<>())) {
                int nextNode = (int) neighbor[0];
                double newProb = prob * neighbor[1];
                
                // 只有当新概率更大时，才更新并加入优先队列
                if (newProb > probMap.getOrDefault(nextNode, 0.0)) {
                    probMap.put(nextNode, newProb);
                    pq.offer(new double[]{nextNode, newProb});
                }
            }
        }
        return 0.0;
    }
}

---

代码模板（BFS 解法）

import java.util.*;

class Solution {
    public double maxProbability(int n, int[][] edges, double[] succProb, int start, int end) {
        // 1. 构建邻接表
        Map<Integer, List<double[]>> graph = new HashMap<>();
        for (int i = 0; i < edges.length; i++) {
            int a = edges[i][0], b = edges[i][1];
            double prob = succProb[i];
            graph.computeIfAbsent(a, x -> new ArrayList<>()).add(new double[]{b, prob});
            graph.computeIfAbsent(b, x -> new ArrayList<>()).add(new double[]{a, prob});
        }

        // 2. 普通队列（Queue）进行 BFS
        Queue<double[]> queue = new LinkedList<>();
        queue.offer(new double[]{start, 1.0});
        
        // 3. 记录最大概率
        Map<Integer, Double> probMap = new HashMap<>();
        probMap.put(start, 1.0);
        
        // 4. BFS 遍历
        while (!queue.isEmpty()) {
            double[] curr = queue.poll();
            int node = (int) curr[0];
            double prob = curr[1];
            
            for (double[] neighbor : graph.getOrDefault(node, new ArrayList<>())) {
                int nextNode = (int) neighbor[0];
                double newProb = prob * neighbor[1];
                
                // 只有当新概率更大时，才更新并加入队列
                if (newProb > probMap.getOrDefault(nextNode, 0.0)) {
                    probMap.put(nextNode, newProb);
                    queue.offer(new double[]{nextNode, newProb});
                }
            }
        }
        return probMap.getOrDefault(end, 0.0);
    }
}

---

Dijkstra 和 BFS 方法的区别

相同点

1. 都用于最优路径问题：都能用于求解从 start 到 end 成功概率最大的路径。
2. 使用邻接表表示图：都采用 Map<Integer, List<double[]>> graph 存储图的邻接表。
3. 使用 probMap 记录最大概率：都维护一个 Map<Integer, Double> probMap 记录从 start 到各个节点的最大成功概率。

不同点

方法	数据结构	访问顺序	适用场景
Dijkstra	优先队列 (PriorityQueue)	每次选择当前最大概率的节点	适用于一般的最优路径问题
BFS	普通队列 (Queue)	逐层扩展搜索	适用于无权图或步数受限的问题

具体区别

1. 队列类型不同

   • Dijkstra 使用 优先队列 (PriorityQueue)，保证每次取出的都是当前概率最大的节点。
   • BFS 使用 普通队列 (Queue)，按层次遍历。

2. 路径更新方式不同

   • Dijkstra 只访问 未确定最大概率路径 的节点。
   • BFS 可能会多次访问某个节点，但只更新更优概率。

3. 适用场景不同

   • Dijkstra 适用于 边权为概率的最优路径问题。
   • BFS 适用于 无权图或限制步数的最优路径问题。

---

无向图与有向图的邻接表存储方式

无向图

graph.computeIfAbsent(a, x -> new ArrayList<>()).add(new double[]{b, prob});
graph.computeIfAbsent(b, x -> new ArrayList<>()).add(new double[]{a, prob});

• 需要 双向存储，a → b 和 b → a 都存在。

有向图

graph.computeIfAbsent(a, x -> new ArrayList<>()).add(new double[]{b, prob});

• 只存储 单向的边，a → b 存储，b → a 不存储（除非明确给出 b → a）。

✅ 总结 ✔ Dijkstra 适用于 最大概率路径问题 (无步数限制，带权重)。 ✔ BFS 适用于 特殊场景，如步数受限的概率路径问题。 ✔ 选择合适的算法，能更高效地解决竞赛问题！