Leetcode.743.网络延迟时间

Leetcode.743.网络延迟时间

题目
题目难度：中等

思路：
1、题目求解经某节点K需要多久能使所有的节点都接收到信号，想到单源最短路径求解。
2、边权值都是1，采用单源最短路径路径的思想，采用迪杰斯特拉算法。
3、迪杰斯特拉算法：
1）以某个节点为起点，分别到各点的最短距离。
2）举例：
S1:1->2最短距离为2；
S2:1->3最短距离为1->2->3=3;
S4:1->4最短距离为1->2->4 = 4;

4、题目意思从节点K出发，到达节点T的时间就是K到T的最短路径长度。所以只需要求出节点K到其余点的所有最短路，求max(所有路长)，如果存在K无法到的则返回-1。

官方代码：

class Solution:
    def networkDelayTime(self, times, n, k):
        g = [[float('inf')] * n for _ in range(n)]
        for x, y, time in times:
            g[x - 1][y - 1] = time

        dist = [float('inf')] * n
        dist[k - 1] = 0
        used = [False] * n
        for _ in range(n):
            x = -1
            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]):
                dist[y] = min(dist[y], dist[x] + time)

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

class Solution {
    public int networkDelayTime(int[][] times, int n, int k) {
        //设置无穷大
        final int INF = Integer.MAX_VALUE/2;
        int[][] path = new int[n][n];
        for(int i = 0;i<n;i++)
        {
            Arrays.fill(path[i],INF);
        }
        for(int[] t:times)
        {
            int x = t[0] - 1,y = t[1]  - 1;
            path[x][y] = t[2];
        }
        int[] dist = new int[n];
        Arrays.fill(dist,INF);
        dist[k-1] = 0;
        boolean[] used = new boolean[n];
        for(int i = 0;i<n;i++)
        {
            int x = -1;
            for(int y = 0;y<n;y++)
            {
                if(!used[y]&&(x==-1 || dist[y]<dist[x]))
                {
                    x = y;
                }
            }
            used[x] = true;
            for(int y = 0;y<n;y++)
            {
                dist[y] = Math.min(dist[y],dist[x] + path[x][y]);
            }
        }
        int ans = Arrays.stream(dist).max().getAsInt();
        return ans == INF?-1:ans;

    }
}