g0701_0800.s0743_network_delay_time.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g0701_0800.s0743_network_delay_time;

// #Medium #Depth_First_Search #Breadth_First_Search #Heap_Priority_Queue #Graph #Shortest_Path
// #2022_03_25_Time_3_ms_(99.87%)_Space_61.2_MB_(75.30%)

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;

/**
 * 743 - Network Delay Time\.
 *
 * Medium
 *
 * 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] = (u_i, v_i, w_i), where u_i is the source node, v_i is the target node, and w_i 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:**
 *
 * ![](https://assets.leetcode.com/uploads/2019/05/23/931_example_1.png)
 *
 * **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 <= u_i, v_i <= n
 * *   u_i != v_i
 * *   0 <= w_i <= 100
 * *   All the pairs (u_i, v_i) are **unique**. (i.e., no multiple edges.)
**/
public class Solution {
    public int networkDelayTime(int[][] times, int n, int k) {
        int[][] graph = new int[n + 1][n + 1];
        for (int[] g : graph) {
            Arrays.fill(g, -1);
        }
        for (int[] t : times) {
            graph[t[0]][t[1]] = t[2];
        }
        boolean[] visited = new boolean[n + 1];
        int[] dist = new int[n + 1];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[k] = 0;
        Queue spfa = new LinkedList<>();
        spfa.add(k);
        visited[k] = true;
        while (!spfa.isEmpty()) {
            int curr = spfa.poll();
            visited[curr] = false;
            for (int i = 1; i <= n; i++) {
                if (graph[curr][i] != -1 && dist[i] > dist[curr] + graph[curr][i]) {
                    dist[i] = dist[curr] + graph[curr][i];
                    if (!visited[i]) {
                        spfa.add(i);
                        visited[i] = true;
                    }
                }
            }
        }
        int result = 0;
        for (int i = 1; i <= n; i++) {
            result = Math.max(dist[i], result);
        }
        return result == Integer.MAX_VALUE ? -1 : result;
    }
}