LC 1376. Time Needed to Inform All Employees (Rust BFS)

Author: raul-sauco

README.md

@@ -410,6 +410,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [1345. Jump Game IV][lc1345]                                                                  | 🔴 Hard    | [![python](res/py.png)][lc1345py] [![rust](res/rs.png)][lc1345rs]                                     |
 | [1354. Construct Target Array With Multiple Sums][lc1354]                                     | 🔴 Hard    | [![python](res/py.png)][lc1354py]                                                                     |
 | [1372. Longest ZigZag Path in a Binary Tree][lc1372]                                          | 🟠 Medium  | [![python](res/py.png)][lc1372py] [![rust](res/rs.png)][lc1372rs]                                     |
+| [1376. Time Needed to Inform All Employees][lc1376]                                           | 🟠 Medium  | [![rust](res/rs.png)][lc1376rs]                                                                       |
 | [1383. Maximum Performance of a Team][lc1383]                                                 | 🔴 Hard    | [![python](res/py.png)][lc1383py]                                                                     |
 | [1396. Design Underground System][lc1396]                                                     | 🟠 Medium  | [![rust](res/rs.png)][lc1396rs]                                                                       |
 | [1402. Reducing Dishes][lc1402]                                                               | 🔴 Hard    | [![python](res/py.png)][lc1402py] [![rust](res/rs.png)][lc1402rs]                                     |
@@ -1417,6 +1418,8 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc1372]: https://leetcode.com/problems/longest-zigzag-path-in-a-binary-tree/
 [lc1372py]: leetcode/longest-zigzag-path-in-a-binary-tree.py
 [lc1372rs]: leetcode/longest-zigzag-path-in-a-binary-tree.rs
+[lc1376]: https://leetcode.com/problems/time-needed-to-inform-all-employees/
+[lc1376rs]: leetcode/time-needed-to-inform-all-employees.rs
 [lc1383]: https://leetcode.com/problems/maximum-performance-of-a-team/
 [lc1383py]: leetcode/maximum-performance-of-a-team.py
 [lc1396]: https://leetcode.com/problems/design-underground-system/

leetcode/time-needed-to-inform-all-employees.rs

@@ -0,0 +1,66 @@
+// 1376. Time Needed to Inform All Employees
+// 🟠 Medium
+//
+// https://leetcode.com/problems/time-needed-to-inform-all-employees/
+//
+// Tags: Tree - Depth-First Search - Breadth-First Search
+
+use std::collections::VecDeque;
+
+struct Solution {}
+impl Solution {
+    /// Reconstruct the tree, in this solution done creating an adjacency list
+    /// in O(n), then use the tree to travel from the root to all the tree nodes
+    /// keeping track of the time used. Return the maximum time to reach any node.
+    ///
+    /// Time complexity: O(n) - Recreate the tree, we could use tree nodes, but
+    /// in Rust is quite verbose so I opted for an adjacency list instead, once
+    /// we have a way to navigate from parents to children, the problem becomes
+    /// a simple tree traversal, we can use BFS or DFS while keeping track of
+    /// the time required to reach every employee, and return the maximum.
+    /// Space complexity: O(n) - The subordinates vector is a 2D vector, but it
+    /// will only have a total of n entries because each node is limited to
+    /// having only one parent, we know the total number of edges = n-1.
+    ///
+    /// Runtime 39 ms Beats 86.67%
+    /// Memory 8.7 MB Beats 33.33%
+    pub fn num_of_minutes(n: i32, head_id: i32, manager: Vec<i32>, inform_time: Vec<i32>) -> i32 {
+        let n = n as usize;
+        let head_id = head_id as usize;
+        let manager = manager
+            .into_iter()
+            .map(|x| x as usize)
+            .collect::<Vec<usize>>();
+        let mut subordinates = vec![vec![]; n];
+        for employee in 0..n {
+            if employee != head_id {
+                subordinates[manager[employee]].push(employee);
+            }
+        }
+        let mut res = 0;
+        // BFS the time needed to inform all employees.
+        let mut queue = VecDeque::from([(head_id, 0)]);
+        while !queue.is_empty() {
+            let (current_employee, current_time) = queue.pop_front().unwrap();
+            let time_to_informed = current_time + inform_time[current_employee];
+            if time_to_informed > res {
+                res = time_to_informed;
+            }
+            for subordinate in subordinates[current_employee].iter() {
+                queue.push_back((*subordinate, time_to_informed));
+            }
+        }
+        res
+    }
+}
+
+fn main() {
+    let tests = [
+        (1, 0, vec![-1], vec![0], 0),
+        (6, 2, vec![2, 2, -1, 2, 2, 2], vec![0, 0, 1, 0, 0, 0], 1),
+    ];
+    for t in tests {
+        assert_eq!(Solution::num_of_minutes(t.0, t.1, t.2, t.3), t.4);
+    }
+    println!("\x1b[92m» All tests passed!\x1b[0m")
+}