冉宝的leetcode笔记--每日一题 8月2日

今天就做leetcode的每日一题吧，还是对我有点难，看了20分钟，完全没有思路。

743. 网络延迟时间

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

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

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

思路：感觉需要用图像的算法，想用bfs，又不知道如何更新。我还是太菜了。

查看官方题解：– 使用单源最短路径Dijkstra。

将所有节点分成两类：已经确定从起点到当前点的最短路径的节点【已经确定节点】，已经未确定从起点到当前点的最短路径的节点【未确定节点】。

每次从【未确定节点】中选择一个与起点距离最短的点，归类为【已经确定节点】，并且用它更新从起点到其他所有【未确定节点】的距离，直到所有节点都被归类为【已经确立节点】。

【更新】： 用节点A更新节点B的意思是，用起点到A的最短长度+A到节点B的长度和起点到节点B的最短距离长度比较，如果前者小于后者就更新，这种操作也叫做【松弛】。

枚举法

from typing import List
class Solution:
    def networkDelayTime(self,times:List[List[int]],n:int,k:int)->int:
        g = [[float("inf")] *n for _ in range(n)]
        for x,y,time in times:
            g[x-1][y-1] = time # 将节点编号-1，使得节点编号位于【0-n-1】范围

        dist = [float('inf')] * n
        dist[k-1] = 0
        used = [False] * n  # 记录点是否到达
        for _ in range(n):
            x = -1
            # 找到没有访问过的最小节点给x
            for y,u in enumerate(used):
                if not u and (x==-1 or dist[y] < dist[x]):
                    x = y

            # 将距离最小的点标记为已经访问
            used[x] = True
            for y,time in enumerate(g[x]): # 更新y的时间
                dist[y] = min(dist[y],dist[x]+time)

        ans = max(dist)
        return ans if ans <float("inf") else -1

复杂度：

• 时间复杂度： O($n^2+m$),其中m为times数组长度。
• 空间复杂度： O($n^2$) ，邻接矩阵的空间。

小根堆写法

"""
使用小根堆寻找【未确定节点】中与起点距离最近的点
"""
from typing import List
import heapq
class Solution:
    def networkDelayTime(self,times:List[List[int]],n:int,k:int)->int:
        g = [[] for _ in range(n)]
        for x,y,time in times:
            g[x-1].append((y-1,time))


        dist = [float("inf") * n]
        dist[k-1] = 0
        q = [(0,k-1)]
        while q:
            time,x = heapq.heappop(q)
            if dist[x] < time :
                continue
            for y,time in g[x]:
                d = dist[x] + time
                if d < dist[y]:
                    dist[y] = d
                    heapq.heappush(q,(d,y))
        ans = max(dist)
        return ans if ans < float("inf") else -1

• 时间复杂度： O($mlogm$),其中m为times数组长度。
• 空间复杂度： O($n+m$) ，邻接矩阵的空间。

值得注意的是，本题边数远大于边数，是一张稠密图，所以枚举写法略快于堆写法。

反思： 这道题卡住的地方： （1）下面写了没有重复边，所以有不需要判断的，（2）默认是无环图。主要是没想到这个算法，每次出最小边进行更新。

自己实现：

from collections import defaultdict
class Solution:
    def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
        g = [[float("inf")] * n for _ in range(n)]

        for src,dst,tim in times:
            g[src-1][dst-1] = tim # 无重复边
        
        # 合并节点
        dist = [float('inf')] * n  # k到各边距离
        dist[k-1] = 0
    
        # 每次从未访问的节点中选择最近的一个 # 一次更新一个节点
        for i in range(n-1): # k 已经到达了
            x = -1 
            for y in not_visted:
                if x==-1 or (g[k-1][y] < g[k-1][x]):
                    x = y 
            dist[x] = g[k-1][x]
            not_visted -= set([x])

            # 更新节点
            for dst,tim in enumerate(g[x]):
                new_tim = dist[x] + tim 
                if new_tim < g[k-1][dst]:
                    g[k-1][dst] = new_tim

        return max(dist) if max(dist) < float("inf") else -1