Leetcode 743.网络延迟时间（Network Delay Time）

Leetcode 743.网络延迟时间

1 题目描述（Leetcode题目链接）

  有 N 个网络节点，标记为 1 到 N。

给定一个列表 times，表示信号经过有向边的传递时间。 times[i] = (u, v, w)，其中 u 是源节点，v 是目标节点， w 是一个信号从源节点传递到目标节点的时间。

现在，我们从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1。

输入：times = [[2,1,1],[2,3,1],[3,4,1]], N = 4, K = 2
输出：2

注意:

• N 的范围在 [1, 100] 之间。
• K 的范围在 [1, N] 之间。
• times 的长度在 [1, 6000] 之间。
• 所有的边 times[i] = (u, v, w) 都有 1 <= u, v <= N 且 0 <= w <= 100。

2 题解

  单源最短路径问题，由于不含负权重的边，所以可以使用Bellman-ford和Dijkstra两种方法解决。算法详情可以看这里

Dijkstra：

class Solution:
    def networkDelayTime(self, times: List[List[int]], N: int, K: int) -> int:
        Adj = collections.defaultdict(list) # 邻接表
        for u, v, w in times:
            Adj[u].append([v, w])

        S = collections.defaultdict(int) # S中为已经算好的最短路径
        Q = [[0, K]]                     # Q为优先队列

        while Q:
            d, u = heapq.heappop(Q)
            if u in S:
                continue
            S[u] = d
            for v, w in Adj[u]:
                if v not in S:
                    heapq.heappush(Q, [d + w, v])

        return max(S.values()) if len(S) == N else -1

Bellman-ford：

class Solution:
    def networkDelayTime(self, times: List[List[int]], N: int, K: int) -> int:
        Adj = collections.defaultdict(list) # 邻接表
        for u, v, w in times:
            Adj[u].append([v, w])

        d = dict.fromkeys([i for i in range(1, N+1)], float("inf"))
        d[K] = 0

        for i in range(1, N):
            for u in range(1, N+1):
                for v, w in Adj[u]:
                    d[v] = min(d[v], d[u] + w)
        res = max(d.values())
        return res if res != float("inf") else -1