力扣：743.网络延迟时间：图最短路径（狄克斯特拉算法）

最新推荐文章于 2023-12-28 10:30:22 发布

Evanhhhh

最新推荐文章于 2023-12-28 10:30:22 发布

阅读量204

点赞数 1

分类专栏：蓝桥杯练习文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/nai_long/article/details/127829835

版权

蓝桥杯练习专栏收录该内容

10 篇文章 0 订阅

订阅专栏

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

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

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

示例 1：

输入：times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
输出：2

示例 2：

输入：times = [[1,2,1]], n = 2, k = 1
输出：1

示例 3：

输入：times = [[1,2,1]], n = 2, k = 2
输出：-1

提示：

1 <= k <= n <= 100
1 <= times.length <= 6000
times[i].length == 3
1 <= ui, vi <= n
ui != vi
0 <= wi <= 100
所有 (ui, vi) 对都 互不相同（即，不含重复边）

狄克斯特拉算法设计要点：

·判断顶点i属于哪个集合，设置一个数组S，S[i]=1表示顶点i属于S 集合，S[i]=0表示顶点i属于U集合。

·保存最短路径长度，由于源点v是已知的，只需要设置一个数组 dist[0..n-1]，dist[i]用来保存从源点v到顶点i的最短路径长度。 dist[i]的初值为<v，i>边上的权值，若顶点v到顶点i没有边，则权值定为∞。以后每考虑一个新的中间点u时，dist[i]的值可能被修改变小。

·（这里没有用到）保存最短路径，设置一个数组path[0..n-1]，其中path[i]存放从源点v到顶点i的最短路径。

本题中，

要使所有节点都收到信号，应去最长的一条路径。使用sort()，取dist中的最大值。注意如果没有路径的话dist的最大值会是INF，则应输出-1。


INF = 6005

class Solution:
    def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
        g = self.trans(times, n)
        return Dijkstral(g, n, k)
    
    def trans(self, times, n):  #将times转换为邻接矩阵
        #节点序号从1开始，设置的邻接矩阵阶数为n+1，第0行0列后续不更改
        g = [[INF] * (n + 1) for i in range(n + 1)]
        for i in range(n + 1):
            g[i][i] = 0
        for i in range(len(times)):
            u = times[i][0]
            v = times[i][1]
            w = times[i][2]
            g[u][v] = w
        return g

def Dijkstral(g, n, v):
    dist = [-1] * (n + 1)  #存放源点v到顶点i的最短路径长度
    s = [0] * (n + 1)  #s[i]=0表示顶点i还没有加入集合
    for i in range(1, n + 1):
        dist[i] = g[v][i]  #最短路径长度初始化
    s[v] = 1  #源点v放入集合中
    u = 0
    for i in range(n - 1):  #循环向集合中添加n-1个节点
        mindis = INF
        for j in range(1, n + 1):
            if s[j] == 0 and dist[j] < mindis:
                u = j
                mindis = dist[j]
        s[u] = 1

        for i in range(1, n + 1):  #更新
            if s[i] == 0:
                if g[u][i] != INF and dist[u] + g[u][i] < dist[i]:
                    dist[i] = dist[u] + g[u][i]

    dist.sort()
    res = dist[len(dist) - 1]
    if res == INF:
        return -1
    else:
        return res