20240105 Finished

src/solution/mod.rs

@@ -12,3 +12,4 @@ mod s1276_number_of_burgers_with_no_waste_of_ingredients;
 mod s0006_zigzag_conversion;
 mod s0007_reverse_integer;
 mod s0004_median_of_two_sorted_arrays;
+mod s0743_network_delay_time;

src/solution/s0743_network_delay_time.rs

@@ -0,0 +1,129 @@
+/**
+ * [743] 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 minimum 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.
+ *  
+ * <strong class="example">Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2019/05/23/931_example_1.png" style="width: 217px; height: 239px;" />
+ * Input: times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
+ * Output: 2
+ * 
+ * <strong class="example">Example 2:
+ * 
+ * Input: times = [[1,2,1]], n = 2, k = 1
+ * Output: 1
+ * 
+ * <strong class="example">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.)
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.cn/problems/network-delay-time/
+// discuss: https://leetcode.cn/problems/network-delay-time/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+use std::cmp::{max, min};
+use std::collections::HashSet;
+
+impl Solution {
+    pub fn network_delay_time(times: Vec<Vec<i32>>, n: i32, k: i32) -> i32 {
+        let n = n as usize;
+        let k = k as usize;
+
+        let mut matrix = Vec::with_capacity(n + 1);
+
+        for _i in 0..=n {
+            let mut line = Vec::with_capacity(n + 1);
+            line.resize(n + 1, i32::MAX);
+            matrix.push(line);
+        }
+
+        for line in &times {
+            matrix[line[0] as usize][line[1] as usize] = line[2];
+        }
+
+        let mut path = HashSet::with_capacity(n + 1);
+        path.insert(k);
+        let mut distances = matrix[k].clone();
+
+        for _ in 2..=n {
+            let (mut index, mut value) = (0usize, i32::MAX);
+
+            for (i, d) in distances.iter().enumerate() {
+                if path.contains(&i) {
+                    continue;
+                }
+
+                if value > *d {
+                    value = *d;
+                    index = i;
+                }
+            }
+
+            if value == i32::MAX {
+                break;
+            }
+
+            path.insert(index);
+
+            for i in 1..=n {
+                if path.contains(&i) {
+                    continue;
+                }
+
+                if matrix[index][i] == i32::MAX {
+                    continue;
+                }
+
+                distances[i] = min(distances[i], value + matrix[index][i]);
+            }
+        }
+
+        let mut result = i32::MIN;
+
+        for i in 1..distances.len() {
+            if i == k {
+                continue
+            }
+
+            result = max(result, distances[i]);
+        }
+
+        return if result == i32::MAX {
+            -1
+        } else {
+            result
+        }
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_743() {
+        assert_eq!(Solution::network_delay_time(
+            vec![vec![2,1,1], vec![2,3,1], vec![3,4,1]], 4, 2), 2);
+        assert_eq!(Solution::network_delay_time(vec![vec![1,2,1]], 2, 1), 1);
+        assert_eq!(Solution::network_delay_time(vec![vec![1,2,1]], 2, 2), -1);
+    }
+}