LeetCode 743. Network Delay Time Dijstrala BFS版 DFS版

There are N network nodes, labelled 1 to N.

Given times, a list of travel times as directed edges times[i] = (u, v, w), where u is the source node, v is the target node, and w is the time it takes for a signal to travel from source to target.

Now, we send a signal from a certain node K. How long will it take for all nodes to receive the signal? If it is impossible, return -1.

 

Example 1:

Input: times = [[2,1,1],[2,3,1],[3,4,1]], N = 4, K = 2
Output: 2

 

Note:

1. N will be in the range [1, 100].
2. K will be in the range [1, N].
3. The length of times will be in the range [1, 6000].
4. All edges times[i] = (u, v, w) will have 1 <= u, v <= N and 0 <= w <= 100.

---------------------------------------------------------------------------

这题写完才发现自己写的是Dijstrala的BFS版本，比用邻接表表示要快很多：

from collections import defaultdict
class Solution:
    def networkDelayTime(self, times, N: int, K: int) -> int:
        nxt_lst,max_dis = defaultdict(list),6000*100
        for time in times:
            u,v,w = time[0],time[1],time[2]
            nxt_lst[u].append((v,w))
        vis = defaultdict(lambda:max_dis)
        layers = [[K],[]]
        vis[K],c,n = 0,0,1
        while (layers[c]):
            for cur in layers[c]:
                cur_dis = vis[cur]
                for v,w in nxt_lst[cur]:
                    if (cur_dis+w<vis[v]):
                        vis[v] = cur_dis+w
                        layers[n].append(v)
            layers[c].clear()
            c,n = n,c
        res = max(vis[i] for i in range(1,N+1))
        return -1 if (res == max_dis) else res

评论区还有Dijstrala的DFS版本，用个优先队列来实现：

class Solution(object):
    def networkDelayTime(self, times, N, K):
        graph = collections.defaultdict(list)
        for u, v, w in times:
            graph[u].append((v, w))

        pq = [(0, K)]
        dist = {}
        while pq:
            d, node = heapq.heappop(pq)
            if node in dist: continue
            dist[node] = d
            for nei, d2 in graph[node]:
                if nei not in dist:
                    heapq.heappush(pq, (d+d2, nei))

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