743. Network Delay Time

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.

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 1 <= w <= 100.

class Solution:
    def networkDelayTime(self, times, N, K):
        """
        :type times: List[List[int]]
        :type N: int
        :type K: int
        :rtype: int
        """
        inf = 999999
        adj = [[inf for t in range(1+N)] for tt in  range(1+N)]
        for u,v,w in times:
            adj[u][v]=w
        collected = [False]*(N+1)
        dist = [inf]*(N+1)
        dist[K] = 0
        
        while(True):
            minIdx, minDis=-1,inf
            for i in range(1, 1+N):
                if not collected[i] and dist[i]<minDis:
                    minDis = dist[i]
                    minIdx = i
            if minIdx==-1:break
            
            collected[minIdx]=True
            for to in range(1, 1+N):
                if adj[minIdx][to]!=inf:
                    if dist[to]>dist[minIdx]+adj[minIdx][to]:
                        dist[to]=dist[minIdx]+adj[minIdx][to]
        
        ret = -1
        for i in range(1,1+N):
            ret = max(ret, dist[i])
            if dist[i]==inf:return -1
        return ret
    
s=Solution()
print(s.networkDelayTime([[2,1,1],[2,3,1],[3,4,1]],4,2))

用优先队列优化一下查找最小值的过程

class Solution:
    def networkDelayTime(self, times, N, K):
        """
        :type times: List[List[int]]
        :type N: int
        :type K: int
        :rtype: int
        """
        import heapq
        adj=[[-1 for _ in range(N+1)] for _ in range(1+N)]
        for u,v,w in times: adj[u][v]=w
        res=[float('inf')]*(1+N)
        pq=[]
        vis=[False]*(1+N)
        heapq.heappush(pq, (0,K))
        
        while pq:
            d,s=heapq.heappop(pq)
            if vis[s]: continue
            vis[s]=True
            res[s]=d
            
            # update
            for i in range(N+1):
                if vis[i] or adj[s][i]==-1: continue
                heapq.heappush(pq, (d+adj[s][i], i))
        
        return -1 if max(res[1:])==float('inf') else max(res[1:])

s=Solution()
print(s.networkDelayTime([[2,1,1],[2,3,1],[3,4,1]],4,2))