【Lintcode】1057. Network Delay Time

题目地址：

https://www.lintcode.com/problem/network-delay-time/description

给定一个非负权边的简单有向图，图顶点编号是$1\sim N$，再给定一个顶点编号$K$，问从$K$到达别的所有顶点的最远距离是多少。如果有顶点到不了则返回$-1$。

可以用Dijkstra算法。思路是，先初始化一个数组dis，记录每个顶点与$K$的距离，每个位置都初始化为正无穷，只有第$K$个初始化为$0$，表示自己到自己的距离是$0$。再初始化一个数组visited，表示最短路径长度是否已经求出，初始化为false（注意这里不把顶点$K$初始化为true，主要是具体的代码实现的需要）。接下来重复下面的循环操作：
寻找visited是false的所有顶点中dis最小的那个顶点，比如说是$V$，那么$V$的最短路径长度已经求出来了，标记其visited为true，并用其更新其邻接点的最短路径长度。“用其更新“的意思是，如果$V$有个邻接点$W$，那么源点$K$到$V$的最短路长度加上$(V,W)$的长度即成为一个$K$到$W$的路径长度。这个长度有可能是比dis中记录的长度要更小的，如果更小，就对dis中记录的长度进行更新。

当循环跳出后，dis里可能存在正无穷，表示的意思是从$K$不存在路径到达这个点。

关于如何寻找visited是false的所有顶点中dis最小的那个顶点，Dijkstra算法可以分为朴素Dijkstra算法和堆优化版Dijkstra算法。

法1：朴素Dijkstra。这里的寻找方式是暴力搜索dis数组。代码如下：

import java.util.*;

public class Solution {
    /**
     * @param times: a 2D array
     * @param N:     an integer
     * @param K:     an integer
     * @return: how long will it take for all nodes to receive the signal
     */
    public int networkDelayTime(int[][] times, int N, int K) {
        // Write your code here
        // 为了方便，这里把顶点编号定义为是从0到N - 1的，也就是将题目所给编号向负方向平移一位
        // dis记录编号对应的顶点与顶点K的距离，先初始化为正无穷
        int[] dis = new int[N];
        Arrays.fill(dis, Integer.MAX_VALUE);
        // 顶点K对应的距离初始化为0
        dis[K - 1] = 0;
        
        // 用邻接表建图。key代表边的出发点，value的list的每一项代表边的到达点以及边的长度
        Map<Integer, List<int[]>> graph = buildGraph(times);
        
        // visited代表编号对应的顶点是否已经算出了最短路长度。一开始都是false
        boolean[] visited = new boolean[N];
        
        while (true) {
        	// 先寻找visited是false的dis最小的点
            int curdis = Integer.MAX_VALUE, cur = -1;
            for (int i = 0; i < N; i++) {
                if (!visited[i] && dis[i] < curdis) {
                    curdis = dis[i];
                    cur = i;
                }
            }
            
            // 如果cur没有被更新，要么所有顶点的最短路都被算出来了，
            // 要么没算出来的顶点到不了
            if (cur == -1) {
                break;
            }
            // cur的最短路算出来了，将其标记为true，并用它来更新其邻接点的最短路长度
            visited[cur] = true;
            // 判断一下cur确实有能走一步到达的点（不判断就NPE了）
            if (graph.containsKey(cur)) {
                for (int[] next : graph.get(cur)) {
                	// 得到邻接点编号，以及从cur到这个点的边的长度
                    int nextPoint = next[0], costFromCur = next[1];
                    // 如果这个点没被算出最短路，则将其更新
                    // 这步判断即使不做程序也是对的，只不过如果一个点已经被算出最短路，
                    // 再去更新相当于什么也没做。判断一下可以节省这个没必要的计算
                    if (!visited[nextPoint]) {
                        dis[nextPoint] = Math.min(dis[nextPoint], dis[cur] + costFromCur);
                    }
                }
            }
        }
        
        // 求最远的顶点的最短路长度
        int res = 0;
        for (int d : dis) {
            res = Math.max(res, d);
        }
        
        // 含正无穷说明有的顶点到不了，返回-1，否则返回res
        return res == Integer.MAX_VALUE ? -1 : res;
    }
    
    private Map<Integer, List<int[]>> buildGraph(int[][] times) {
        Map<Integer, List<int[]>> graph = new HashMap<>();
        for (int[] time : times) {
            int s = time[0] - 1, t = time[1] - 1, dis = time[2];
            graph.putIfAbsent(s, new ArrayList<>());
            graph.get(s).add(new int[]{t, dis});
        }
        
        return graph;
    }
}

时间复杂度$O(V^2+E)$，建图花了$O(V+E)$的时间，至于Dijkstra算法本身的时间复杂度事实上是$O(V^2)$，空间$O(V+E)$。

法2：堆优化版Dijkstra算法。这里的寻找方式是，开一个最小堆，按照顶点与源点的已知最短路的距离排序，当更新完某个点的dis时，将其与其最短路距离做成一个pair，一起加入一个最小堆中（这会造成）。这样每次从堆中取出pair的时候，就已经找到了最近的点。但这里要注意，堆顶的visited未必是false（原因是同一个顶点可能会被更新多次，从而加入堆多次。而要更新一个已经在堆里的元素是很难做到的），所以遇到true（也就是算过最短路）的时候需要跳过该次循环。代码如下：

import java.util.*;

public class Solution {
    /**
     * @param times: a 2D array
     * @param N:     an integer
     * @param K:     an integer
     * @return: how long will it take for all nodes to receive the signal
     */
    public int networkDelayTime(int[][] times, int N, int K) {
        // Write your code here
        int[] dis = new int[N];
        Arrays.fill(dis, Integer.MAX_VALUE);
        dis[K - 1] = 0;
        
        Map<Integer, List<int[]>> graph = buildGraph(times);
        boolean[] visited = new boolean[N];
        // 构造一个最小堆，堆里存放的是顶点编号和其当前已经算出的最短路路径长度；长度小者优先
        PriorityQueue<int[]> minHeap = new PriorityQueue<>((p1, p2) -> Integer.compare(p1[1], p2[1]));
        // 把源点自己加入堆
        minHeap.offer(new int[]{K - 1, 0});
        
        // 记录最终答案
        int res = 0;
        while (!minHeap.isEmpty()) {
        	// 取出堆顶，堆顶是未计算出最短路长度的顶点中离源点最近的那个的备选，
        	// 因为还需要判断一下其visited是否是false
            int[] curV = minHeap.poll();
            int v = curV[0];
            // 如果算出过，则略过该点
            if (visited[v]) {
                continue;
            }
            
            // 否则该点要标记为算出过，更新res，并且将未算过的点的数量减去1
            visited[v] = true;
            res = curV[1];
            N--;
            
            if (graph.containsKey(v)) {
                for (int[] next : graph.get(v)) {
                    int nextv = next[0], disFromV = next[1];
                    // 如果这个顶点未算过，并且可以更新，则对其更新并加入堆
                    if (!visited[nextv] && dis[v] + disFromV < dis[nextv]) {
                        dis[nextv] = dis[v] + disFromV;
                        minHeap.offer(new int[]{nextv, dis[nextv]});
                    }
                }
            }
        }
        
        // 如果N不等于0说明有些点到不了，返回-1；否则返回res
        return N == 0 ? res : -1;
    }
    
    private Map<Integer, List<int[]>> buildGraph(int[][] times) {
        Map<Integer, List<int[]>> graph = new HashMap<>();
        for (int[] time : times) {
            int s = time[0] - 1, t = time[1] - 1, dis = time[2];
            graph.putIfAbsent(s, new ArrayList<>());
            graph.get(s).add(new int[]{t, dis});
        }
        
        return graph;
    }
}

时间复杂度$O(E\log E+V+E)$，建图花了$O(V+E)$的时间，Dijkstra算法本身花了$O(E\log E)$的时间。空间$O(V+E)$。

算法正确性证明：
设$d$数组即为算法算出的每个点与源点$s$的最短路距离，$\delta (u,v)$表示从$u$到$v$的真正的最短路距离，$w(u,v)$表示边$u\to v$的长度。只需证明算法结束后$d[v]=\delta (s,v)$对任意$v$都成立。

首先，算法计算出的$d[v]$是某一条从$s$到$v$的路径长度，所以$d[v]\ge \delta (s,v)$。我们只需证明在将$v$的visited标记为true的时候，$d[v]=\delta (s,v)$即可。
按照visited标记为true的先后顺序对顶点做数学归纳法。第一个被标记的点是$s$自己，而$d[s]$恰好是$0$，结论正确。假设结论对某个顶点不成立，我们挑出第一个不成立的那个顶点$u$，所以$d[u]>\delta (s,u)$。假设从$s$到$u$的真实最短路径是$P$，设$u$之前被标记过的点的集合是$S$，找到$P$中第一次从$S$中的点到$S$外的点的边，记为$x\to y$。由归纳假设知$d[x]=\delta (s,x)$。而$P$是个最短路，所以$\delta (s,y)=\delta (s,x)+w(x,y)$（这是因为最短路有最优子结构）。而算法保证了在将$x$标记之后，$d[y]$也会得到更新成为$\delta (s,y)$。显然$\delta (s,y)\le \delta (s,u)$。由于$y\notin S$，$u\notin S$，而$u$比$y$更先被标记（即更先出优先队列），所以$d[u]\le d[y]$，所以$$d[u]\le d[y]=\delta (s,y)\le \delta (s,u)$$与$d[u]>\delta (s,u)$矛盾。所以算法正确。

注解：我们可以看出，当图是稀疏图的时候，堆优化版的算法效率更高；而当图很稠密的时候（这个时候$E\approx V^2$），朴素的算法效率更高。而大多数情况下我们遇到的图都是稀疏图，所以通常都用堆优化版的算法。