LC 2406. Divide Intervals Into Minimum Number of Groups (Rust)

Author: raul-sauco

README.md

@@ -697,6 +697,7 @@ to the solution in this repository.
 | [2391. Minimum Amount of Time to Collect Garbage][lc2391]                                     | 🟠 Medium  | [![rust](res/rs.png)][lc2391rs]                                                                       |
 | [2402. Meeting Rooms III][lc2402]                                                             | 🔴 Hard    | [![rust](res/rs.png)][lc2402rs]                                                                       |
 | [2405. Optimal Partition of String][lc2405]                                                   | 🟠 Medium  | [![python](res/py.png)][lc2405py] [![rust](res/rs.png)][lc2405rs]                                     |
+| [2406. Divide Intervals Into Minimum Number of Groups][lc2406]                                | 🟠 Medium  | [![rust](res/rs.png)][lc2406rs]                                                                       |
 | [2416. Sum of Prefix Scores of Strings][lc2416]                                               | 🔴 Hard    | [![rust](res/rs.png)][lc2416rs]                                                                       |
 | [2421. Number of Good Paths][lc2421]                                                          | 🔴 Hard    | [![python](res/py.png)][lc2421py] [![rust](res/rs.png)][lc2421rs]                                     |
 | [2433. Find The Original Array of Prefix Xor][lc2433]                                         | 🔴 Hard    | [![rust](res/rs.png)][lc2433rs]                                                                       |
@@ -2304,6 +2305,8 @@ to the solution in this repository.
 [lc2405]: https://leetcode.com/problems/optimal-partition-of-string/
 [lc2405py]: leetcode/optimal-partition-of-string.py
 [lc2405rs]: leetcode/optimal-partition-of-string.rs
+[lc2406]: https://leetcode.com/problems/divide-intervals-into-minimum-number-of-groups/
+[lc2406rs]: leetcode/divide-intervals-into-minimum-number-of-groups.rs
 [lc2416]: https://leetcode.com/problems/sum-of-prefix-scores-of-strings/
 [lc2416rs]: leetcode/sum-of-prefix-scores-of-strings.rs
 [lc2421]: https://leetcode.com/problems/number-of-good-paths/

leetcode/divide-intervals-into-minimum-number-of-groups.rs

@@ -0,0 +1,71 @@
+// 2406. Divide Intervals Into Minimum Number of Groups
+// 🟠 Medium
+//
+// https://leetcode.com/problems/divide-intervals-into-minimum-number-of-groups/
+//
+// Tags: Array - Two Pointers - Greedy - Sorting - Heap (Priority Queue) - Prefix Sum
+
+use std::{cmp::Reverse, collections::BinaryHeap};
+
+struct Solution;
+impl Solution {
+    /// Sort the intervals to process them in order by start time. Use a heap to keep track of the
+    /// earliest end time of any of the existing groups. For each interval, check if we can add it
+    /// to the group at the top of the heap. This greedy solution works because we have guaranteed
+    /// both that we have the group with the earliest end and the interval with the earliest start,
+    /// if we cannot add it to that group, we cannot add any other later interval to that group and
+    /// we cannot add this interval to any other groups, we need to create a new group.
+    ///
+    /// Time complexity: O(nlog(n)) - Sorting the intervals and pushing/popping from the heap.
+    /// Space complexity: O(n) - The sorted intervals are size n, the heap can grow to size n.
+    ///
+    /// Runtime 37 ms Beats 100%
+    /// Memory 9.78 MB Beats 33%
+    pub fn min_groups(intervals: Vec<Vec<i32>>) -> i32 {
+        let mut intervals = intervals.iter().map(|v| (v[0], v[1])).collect::<Vec<_>>();
+        intervals.sort_unstable();
+        let mut groups = BinaryHeap::<Reverse<i32>>::new();
+        for (start, end) in intervals {
+            if let Some(Reverse(group_end)) = groups.peek().copied() {
+                if start > group_end {
+                    groups.pop();
+                }
+            }
+            groups.push(Reverse(end));
+        }
+        groups.len() as _
+    }
+}
+
+// Tests.
+fn main() {
+    let tests = [
+        (vec![[5, 10], [6, 8], [1, 5], [2, 3], [1, 10]], 3),
+        (vec![[1, 3], [5, 6], [8, 10], [11, 13]], 1),
+    ];
+    println!("\n\x1b[92m» Running {} tests...\x1b[0m", tests.len());
+    let mut success = 0;
+    for (i, t) in tests.iter().enumerate() {
+        let res = Solution::min_groups(t.0.iter().map(|a| a.to_vec()).collect());
+        if res == t.1 {
+            success += 1;
+            println!("\x1b[92m✔\x1b[95m Test {} passed!\x1b[0m", i);
+        } else {
+            println!(
+                "\x1b[31mx\x1b[95m Test {} failed expected: {:?} but got {}!!\x1b[0m",
+                i, t.1, res
+            );
+        }
+    }
+    println!();
+    if success == tests.len() {
+        println!("\x1b[30;42m✔ All tests passed!\x1b[0m")
+    } else if success == 0 {
+        println!("\x1b[31mx \x1b[41;37mAll tests failed!\x1b[0m")
+    } else {
+        println!(
+            "\x1b[31mx\x1b[95m {} tests failed!\x1b[0m",
+            tests.len() - success
+        )
+    }
+}