LeetCode - Network Delay Time

You are given a network of n nodes, labeled from 1 to n. You are also given times, a list of travel times as directed edges times[i] = (ui, vi, wi), where ui is the source node, vi is the target node, and wi is the time it takes for a signal to travel from source to target.

We will send a signal from a given node k. Return the time it takes for all the n nodes to receive the signal. If it is impossible for all the n nodes to receive the signal, return -1.

 

Example 1:


Input: times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
Output: 2
Example 2:

Input: times = [[1,2,1]], n = 2, k = 1
Output: 1
Example 3:

Input: times = [[1,2,1]], n = 2, k = 2
Output: -1
 

Constraints:

1 <= k <= n <= 100
1 <= times.length <= 6000
times[i].length == 3
1 <= ui, vi <= n
ui != vi
0 <= wi <= 100
All the pairs (ui, vi) are unique. (i.e., no multiple edges.)

Bellman-Ford single source shortest path alogithm:

Ttime complexity: O(VE)

class Solution {
    public int networkDelayTime(int[][] times, int n, int k) {
        // Step 1: Initialize distances from src to all other 
        // vertices as INFINITE 
        // src will have distance as 0
        int[] leastTimes = new int[n + 1];
        Arrays.fill(leastTimes, Integer.MAX_VALUE);
        leastTimes[k] = 0;
        // Step 2: Relax all edges |V| - 1 times. A simple 
        // shortest path from src to any other vertex can 
        // have at-most |V| - 1 edges 
        for (int i = 1; i< n; i++) {
            for(int[] time : times) {
                int u = time[0], v = time[1], w = time[2];
                if (leastTimes[u] != Integer.MAX_VALUE && leastTimes[v] > leastTimes[u] + w) {
                    leastTimes[v] = leastTimes[u] + w;
                }
            }
        }
        // check to see if any of the distances are MAX_VALUE, this will
        // show that the node was never relaxed so return -1
        int delay = 0;
        for (int i = 1; i< leastTimes.length; i++) {
            if (leastTimes[i] == Integer.MAX_VALUE) {
                return -1;
            }
            if (leastTimes[i] > delay) {
                delay = leastTimes[i];
            }
        }
        return delay;
    }
}

 Dijkstra Algorithm SSSP

adjacency list + priority queue, time complexity: O(Vlog(E))

class Solution {
    //Dijkstra algorithm
    public int networkDelayTime(int[][] times, int n, int k) {
        int[] visited = new int[n+1];
        Map<Integer, List<int[]>> map = new HashMap<>();
        for (int i = 1; i <=n; i++) {
            map.put(i, new ArrayList<int[]>());
        }
        for (int[] time : times) {
            int u = time[0], v = time[1], w = time[2];
            map.get(u).add(new int[]{v, w});
        }
        
        int[] leastTimes = new int[n + 1];
        Arrays.fill(leastTimes, Integer.MAX_VALUE);
        leastTimes[k] = 0;
        PriorityQueue<int[]> queue = new PriorityQueue<>(((e1, e2) -> e1[1] - e2[1]));
        queue.offer(new int[]{k, 0});
        while(!queue.isEmpty()) {
            int[] leastTime = queue.poll();
            if (visited[leastTime[0]] == 1) {
                continue;
            }
            
            // find adjacent nodes and update their distances
            // Node that after the step, the priority queue may have same node with different distance value
            // But that should be find since they are ordered and once the shortest processed, it will be marked as visited
            for (int[] node : map.get(leastTime[0])) {
                if(visited[node[0]] == 0 && leastTimes[node[0]] > leastTime[1] + node[1]){
                    leastTimes[node[0]] = leastTime[1] + node[1];
                    queue.offer(new int[]{node[0], leastTimes[node[0]]});
                }
            }
            //since u != v, so we can update the status at the end
            visited[leastTime[0]] = 1;
        }
        
        // check to see if any of the distances are MAX_VALUE, this will
        // show that the node was never relaxed so return -1
        int delay = 0;
        for (int i = 1; i< leastTimes.length; i++) {
            if (leastTimes[i] == Integer.MAX_VALUE) {
                return -1;
            }
            if (leastTimes[i] > delay) {
                delay = leastTimes[i];
            }
        }
        return delay;
    }
}