LC 2009. Minimum Number of Operations to Make Array Continuous (Rust SW)

Author: raul-sauco

README.md

@@ -254,6 +254,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [446. Arithmetic Slices II - Subsequence][lc446]                                              | 🔴 Hard    | [![python](res/py.png)][lc446py]                                                                      |
 | [451. Sort Characters By Frequency][lc451]                                                    | 🟠 Medium  | [![python](res/py.png)][lc451py]                                                                      |
 | [452. Minimum Number of Arrows to Burst Balloons][lc452]                                      | 🟠 Medium  | [![python](res/py.png)][lc452py]                                                                      |
+| [456. 132 Pattern][lc456]                                                                     | 🟠 Medium  | [![rust](res/rs.png)][lc456rs]                                                                        |
 | [458. Poor Pigs][lc458]                                                                       | 🔴 Hard    | [![python](res/py.png)][lc458py]                                                                      |
 | [460. LFU Cache][lc460]                                                                       | 🔴 Hard    | [![python](res/py.png)][lc460py]                                                                      |
 | [472. Concatenated Words][lc472]                                                              | 🔴 Hard    | [![python](res/py.png)][lc472py] [![rust](res/rs.png)][lc472rs]                                       |
@@ -522,6 +523,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [1991. Find the Middle Index in Array][lc1991]                                                | 🟢 Easy    | [![python](res/py.png)][lc1991py]                                                                     |
 | [1996. The Number of Weak Characters in the Game][lc1996]                                     | 🟠 Medium  | [![python](res/py.png)][lc1996py]                                                                     |
 | [2007. Find Original Array From Doubled Array][lc2007]                                        | 🟠 Medium  | [![python](res/py.png)][lc2007py]                                                                     |
+| [2009. Minimum Number of Operations to Make Array Continuous][lc2009]                         | 🔴 Hard    | [![rust](res/rs.png)][lc2009rs]                                                                       |
 | [2013. Detect Squares][lc2013]                                                                | 🟠 Medium  | [![python](res/py.png)][lc2013py]                                                                     |
 | [2024. Maximize the Confusion of an Exam][lc2024]                                             | 🟠 Medium  | [![rust](res/rs.png)][lc2024rs]                                                                       |
 | [2090. K Radius Subarray Averages][lc2090]                                                    | 🟠 Medium  | [![rust](res/rs.png)][lc2090rs]                                                                       |
@@ -1132,6 +1134,8 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc451py]: leetcode/sort-characters-by-frequency.py
 [lc452]: https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/
 [lc452py]: leetcode/minimum-number-of-arrows-to-burst-balloons.py
+[lc456]: https://leetcode.com/problems/132-pattern/
+[lc456rs]: leetcode/132-pattern.rs
 [lc458]: https://leetcode.com/problems/poor-pigs/
 [lc458py]: leetcode/poor-pigs.py
 [lc460]: https://leetcode.com/problems/lfu-cache/
@@ -1730,6 +1734,8 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc1996py]: leetcode/the-number-of-weak-characters-in-the-game.py
 [lc2007]: https://leetcode.com/problems/find-original-array-from-doubled-array/
 [lc2007py]: leetcode/find-original-array-from-doubled-array.py
+[lc2009]: https://leetcode.com/problems/minimum-number-of-operations-to-make-array-continuous/
+[lc2009rs]: leetcode/minimum-number-of-operations-to-make-array-continuous.rs
 [lc2013]: https://leetcode.com/problems/detect-squares/
 [lc2013py]: leetcode/detect-squares.py
 [lc2024]: https://leetcode.com/problems/maximize-the-confusion-of-an-exam/

leetcode/132-pattern.rs

@@ -0,0 +1,65 @@
+// 456. 132 Pattern
+// 🟠 Medium
+//
+// https://leetcode.com/problems/132-pattern/
+//
+// Tags: Array - Binary Search - Stack - Monotonic Stack - Ordered Set
+
+struct Solution;
+impl Solution {
+    /// Precompute an array of minimum prefix at each position, then iterate
+    /// from the back of the input storing the biggest values seen to the right.
+    /// At each position, we pop any values from the stack that are smaller than
+    /// the minimum at the current point, since we won't be able to use them,
+    /// then we check if the current value is a peak between the top of the
+    /// stack and the minimum to the left, if it is, we return true, we found a
+    /// 132 pattern, otherwise we push the value into the monotonic stack, where
+    /// it will be the smallest value at the top, and keep searching.
+    ///
+    /// Time complexity: O(n) - We iterate twice over the input array, once
+    /// forward and once backwards, we also may push and pop each element into
+    /// the stack, but once at most.
+    /// Space complexity: O(n) - The vector of minimums and the stack are O(n)
+    ///
+    /// Runtime 9 ms Beats 25.40%
+    /// Memory 5.34 MB Beats 9.89%
+    pub fn find132pattern(nums: Vec<i32>) -> bool {
+        let mins = nums
+            .iter()
+            .scan(nums[0], |state, &x| {
+                *state = x.min(*state);
+                Some(*state)
+            })
+            .collect::<Vec<i32>>();
+        // A monotonic stack with the biggest values seen to the right.
+        let mut stack = vec![nums[nums.len() - 1]];
+        for i in (0..nums.len() - 1).rev() {
+            if nums[i] <= mins[i] {
+                continue;
+            }
+            while !stack.is_empty() && *stack.last().unwrap() <= mins[i] {
+                stack.pop();
+            }
+            if !stack.is_empty() && *stack.last().unwrap() < nums[i] {
+                return true;
+            }
+            stack.push(nums[i]);
+        }
+        false
+    }
+}
+
+// Tests.
+fn main() {
+    let tests = [
+        (vec![3, 1, 4, 2], true),
+        (vec![-1, 3, 2, 0], true),
+        (vec![1, 2, 3, 4], false),
+        (vec![3, 5, 0, 3, 4], true),
+        (vec![1, 0, 1, -4, -3], false),
+    ];
+    for t in tests {
+        assert_eq!(Solution::find132pattern(t.0), t.1);
+    }
+    println!("\x1b[92m» All tests passed!\x1b[0m")
+}

leetcode/minimum-number-of-operations-to-make-array-continuous.rs

@@ -0,0 +1,70 @@
+// 2009. Minimum Number of Operations to Make Array Continuous
+// 🔴 Hard
+//
+// https://leetcode.com/problems/minimum-number-of-operations-to-make-array-continuous/
+//
+// Tags: Array - Binary Search
+
+struct Solution;
+impl Solution {
+    /// Sort the input, then use a sliding window technique, the sliding window
+    /// is computed using the value of the left edge and the value that the
+    /// right edge should have for the array to be continuous. When we find these
+    /// two indexes, we know that the elements between these two indexes can be
+    /// used as part of the continuous array, and we will need to change all
+    /// the others. We try all left boundaries and keep the one that results in
+    /// the least amount of substitutions.
+    ///
+    /// Time complexity: O(n*log(n)) - Sorting the input vector has the highest
+    /// complexity, the sliding window algorithm runs in O(n) because r never
+    /// moves backwards.
+    /// Space complexity: O(n) - We keep a local copy of nums, in languages that
+    /// let us mutate the input, we could sort the input vector. Besides that,
+    /// we use, probably, O(log(n)) extra space for the sorting and constant
+    /// extra space besides that.
+    ///
+    /// Runtime 21 ms Beats 100%
+    /// Memory 3.90 MB Beats 100%
+    pub fn min_operations(nums: Vec<i32>) -> i32 {
+        // We are looking for a minimum number of substitutions.
+        let mut res = i32::MAX;
+        let n = nums.len();
+        let offset = n as i32 - 1;
+        // We want a sorted copy of nums with all duplicates removed.
+        let mut nums = nums;
+        nums.sort_unstable();
+        nums.dedup();
+        // Store the value that should be at the right end of the continuous vector.
+        let mut x;
+        let mut r = 0;
+        for l in 0..nums.len() {
+            x = nums[l] + offset;
+            while r < nums.len() && nums[r] <= x {
+                r += 1;
+                // if r >= nums.len() || nums[r] > x {
+                // break;
+                //}
+            }
+            // We can use the elements between l and r-1 to build a continuous
+            // sequence, how many more do we need? These we need to convert.
+            res = res.min((n + l - r) as i32);
+            if r == nums.len() {
+                break;
+            }
+        }
+        res
+    }
+}
+
+// Tests.
+fn main() {
+    let tests = [
+        (vec![4, 2, 5, 3], 0),
+        (vec![1, 2, 3, 5, 6], 1),
+        (vec![1, 10, 100, 1000], 3),
+    ];
+    for t in tests {
+        assert_eq!(Solution::min_operations(t.0), t.1);
+    }
+    println!("\x1b[92m» All tests passed!\x1b[0m")
+}