LC 962. Maximum Width Ramp (Rust)

Author: raul-sauco

README.md

@@ -432,6 +432,7 @@ to the solution in this repository.
 | [953. Verifying an Alien Dictionary][lc953]                                                   | 🟢 Easy    | [![python](res/py.png)][lc953py] [![rust](res/rs.png)][lc953rs]                                       |
 | [956. Tallest Billboard][lc956]                                                               | 🟠 Medium  | [![python](res/py.png)][lc956py]                                                                      |
 | [958. Check Completeness of a Binary Tree][lc958]                                             | 🟠 Medium  | [![python](res/py.png)][lc958py] [![rust](res/rs.png)][lc958rs]                                       |
+| [962. Maximum Width Ramp][lc962]                                                              | 🟠 Medium  | [![rust](res/rs.png)][lc962rs]                                                                        |
 | [967. Numbers With Same Consecutive Differences][lc967]                                       | 🟠 Medium  | [![python](res/py.png)][lc967py]                                                                      |
 | [968. Binary Tree Cameras][lc968]                                                             | 🔴 Hard    | [![python](res/py.png)][lc968py]                                                                      |
 | [973. K Closest Points to Origin][lc973]                                                      | 🟠 Medium  | [![python](res/py.png)][lc973py]                                                                      |
@@ -1713,6 +1714,8 @@ to the solution in this repository.
 [lc958]: https://leetcode.com/problems/check-completeness-of-a-binary-tree/
 [lc958py]: leetcode/check-completeness-of-a-binary-tree.py
 [lc958rs]: leetcode/check-completeness-of-a-binary-tree.rs
+[lc962]: https://leetcode.com/problems/maximum-width-ramp/
+[lc962rs]: leetcode/maximum-width-ramp.rs
 [lc967]: https://leetcode.com/problems/numbers-with-same-consecutive-differences/
 [lc967py]: leetcode/numbers-with-same-consecutive-differences.py
 [lc968]: https://leetcode.com/problems/binary-tree-cameras/

leetcode/maximum-width-ramp.rs

@@ -0,0 +1,96 @@
+// 962. Maximum Width Ramp
+// 🟠 Medium
+//
+// https://leetcode.com/problems/maximum-width-ramp/
+//
+// Tags: Array - Stack - Monotonic Stack
+
+struct Solution;
+impl Solution {
+    /// One pass using monotonic stack, but for each value iterate the monotonic stack back while
+    /// the top of the stack is less or equal to the current value.
+    ///
+    /// Time complexity: O(n)
+    /// Space complexity: O(n)
+    ///
+    /// Runtime 8 ms Beats 20%
+    /// Memory 2.86 MB Beats 20%
+    #[allow(dead_code)]
+    pub fn max_width_ramp_one_pass(nums: Vec<i32>) -> i32 {
+        let mut seen = vec![0];
+        let mut res = 0;
+        for i in 1..nums.len() {
+            let mut seen_idx = seen.len() - 1;
+            if nums[i] < nums[seen[seen_idx]] {
+                seen.push(i);
+            } else {
+                while nums[i] >= nums[seen[seen_idx]] {
+                    res = res.max(i - seen[seen_idx]);
+                    if seen_idx == 0 {
+                        break;
+                    }
+                    seen_idx -= 1;
+                }
+            }
+        }
+        res as _
+    }
+
+    /// Two passes, create a monotonic non-increasing stack on the first one, on the second pass,
+    /// find indexes of the greatest ramp.
+    ///
+    /// Time complexity: O(n)
+    /// Space complexity: O(n)
+    ///
+    /// Runtime 7 ms Beats 20%
+    /// Memory 2.77 MB Beats 20%
+    pub fn max_width_ramp(nums: Vec<i32>) -> i32 {
+        let mut stack = vec![];
+        for i in 0..nums.len() {
+            if stack.is_empty() || nums[stack[stack.len() - 1]] > nums[i] {
+                stack.push(i);
+            }
+        }
+        let mut res = 0;
+        for i in (0..nums.len()).rev() {
+            while !stack.is_empty() && nums[*stack.last().unwrap()] <= nums[i] {
+                res = res.max(i - stack.pop().unwrap());
+            }
+        }
+        res as _
+    }
+}
+
+// Tests.
+fn main() {
+    let tests = [
+        (vec![6, 2], 0),
+        (vec![6, 0, 8, 2, 1, 5], 4),
+        (vec![9, 8, 1, 0, 1, 9, 4, 0, 4, 1], 7),
+    ];
+    println!("\n\x1b[92m» Running {} tests...\x1b[0m", tests.len());
+    let mut success = 0;
+    for (i, t) in tests.iter().enumerate() {
+        let res = Solution::max_width_ramp(t.0.clone());
+        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
+        )
+    }
+}