Mono st (#80)

* saving progress

* saving progress

* Update mono_st.rs

* saving progress

* saving progress

* saving progress

* another assert

* remove

* add test

* asdf

* finish

* better

* fix

* uncomment

* Update mono_st.rs

* Update mono_range.rs

* Update mono_st.rs

* fix

* change style

* nit

* change

* nits

* different style

* golf

* consistency with c++ PTC

* finish doc for mono st

* simplify test

* add

* add docs for mono range

* fix typo

* nit

* fix

* nit to docs

* now ACs

---------

Co-authored-by: Luke Videckis <lukevideckis@gmail.com>

Author: lrvideckis

Cargo.toml

@@ -203,3 +203,7 @@ path = "examples/helpers/lis_yosupo.rs"
 [[example]]
 name = "lis_pop"
 path = "examples/helpers/lis_pop.rs"
+
+[[example]]
+name = "mono_st"
+path = "examples/monotonic/mono_st.rs"

examples/monotonic/mono_st.rs

@@ -0,0 +1,87 @@
+// verification-helper: PROBLEM https://judge.yosupo.jp/problem/staticrmq
+
+use proconio::input;
+use programming_team_code_rust::data_structures::rmq::RMQ;
+use programming_team_code_rust::monotonic::mono_range::mono_range;
+use programming_team_code_rust::monotonic::mono_st::mono_st;
+
+fn main() {
+    input! {
+        n: usize,
+        q: usize,
+        a: [u32; n],
+    }
+
+    let rmq = RMQ::new(
+        &(0..n).map(|i| (i, i)).collect::<Vec<_>>(),
+        |(min_i1, max_i1), (min_i2, max_i2)| {
+            let min_idx = if a[min_i1] < a[min_i2] {
+                min_i1
+            } else {
+                min_i2
+            };
+            let max_idx = if a[max_i1] > a[max_i2] {
+                max_i1
+            } else {
+                max_i2
+            };
+            (min_idx, max_idx)
+        },
+    );
+
+    let compares = vec![
+        |x: u32, y: u32| -> bool { x.le(&y) },
+        |x: u32, y: u32| -> bool { x.lt(&y) },
+        |x: u32, y: u32| -> bool { x.ge(&y) },
+        |x: u32, y: u32| -> bool { x.gt(&y) },
+    ];
+
+    let mut le = Vec::new();
+    let mut ri = Vec::new();
+    for &cmp in &compares {
+        le.push(mono_st(&a, |&x, &y| cmp(x, y)));
+        ri.push(mono_range(le.last().unwrap()));
+    }
+    let le = le;
+    let ri = ri;
+
+    for curr_le in &le {
+        let mut count_index = vec![0; n];
+        for i in 0..n {
+            let mut j = i.wrapping_sub(1);
+            while j != curr_le[i] {
+                count_index[j] += 1;
+                j = curr_le[j];
+            }
+        }
+        let mut j = n.wrapping_sub(1);
+        while j != usize::MAX {
+            count_index[j] += 1;
+            j = curr_le[j];
+        }
+        assert_eq!(count_index, vec![1; n]);
+    }
+
+    for _ in 0..q {
+        input! {
+            l: usize,
+            r: usize,
+        }
+
+        let (min_idx, max_idx) = rmq.query(l..r);
+
+        for i in 0..4 {
+            let idx = if i < 2 { min_idx } else { max_idx };
+            let rmq_res = rmq.query(le[i][idx].wrapping_add(1)..ri[i][idx]);
+            assert_eq!(a[if i < 2 { rmq_res.0 } else { rmq_res.1 }], a[idx]);
+            if le[i][idx] != usize::MAX {
+                assert!(compares[i](a[le[i][idx]], a[idx]));
+            }
+            if ri[i][idx] < n {
+                assert!(!compares[i](a[idx], a[ri[i][idx]]));
+            }
+        }
+
+        println!("{}", a[min_idx]);
+    }
+}

src/lib.rs

@@ -2,5 +2,6 @@
 pub mod data_structures;
 pub mod graphs;
 pub mod helpers;
+pub mod monotonic;
 pub mod numbers;
 pub mod strings;

src/monotonic/mod.rs

@@ -0,0 +1,3 @@
+//! # Monotonic
+pub mod mono_range;
+pub mod mono_st;

src/monotonic/mono_range.rs

@@ -0,0 +1,30 @@
+//! # Monotonic Range
+
+/// Gets vec ri where ri\[i\] = smallest index such that i < ri\[i\] && !a\[i\].cmp(&a\[ri\[i\]\]), or n
+///
+/// # Example
+/// ```
+/// use programming_team_code_rust::monotonic::mono_st::mono_st;
+/// use programming_team_code_rust::monotonic::mono_range::mono_range;
+///
+/// let a: Vec<u32> = vec![3, 1, 2, 2];
+///
+/// let le = mono_st(&a, |x, y| x.lt(y));
+/// let ri = mono_range(&le);
+/// assert_eq!(ri, [1, 4, 3, 4]);
+/// ```
+///
+/// # Complexity
+/// - Time: O(n)
+/// - Space: O(n)
+pub fn mono_range(le: &[usize]) -> Vec<usize> {
+    let mut ri = vec![le.len(); le.len()];
+    for i in 0..le.len() {
+        let mut j = i.wrapping_sub(1);
+        while j != le[i] {
+            ri[j] = i;
+            j = le[j];
+        }
+    }
+    ri
+}

src/monotonic/mono_st.rs

@@ -0,0 +1,51 @@
+//! # Monotonic Stack
+
+/// Gets vec le where le\[i\] = largest index such that le\[i\] < i && a\[le\[i\]\].cmp(&a\[i\]), or usize::MAX
+///
+/// # Example
+/// ```
+/// use programming_team_code_rust::monotonic::mono_st::mono_st;
+///
+/// let a: Vec<u32> = vec![3, 1, 2, 2];
+/// let n = a.len();
+///
+/// assert_eq!(mono_st(&a, |x, y| x.lt(y)), [usize::MAX, usize::MAX, 1, 1]);
+/// assert_eq!(mono_st(&a, |x, y| x.le(y)), [usize::MAX, usize::MAX, 1, 2]);
+/// assert_eq!(mono_st(&a, |x, y| x.gt(y)), [usize::MAX, 0, 0, 0]);
+/// assert_eq!(mono_st(&a, |x, y| x.ge(y)), [usize::MAX, 0, 0, 2]);
+///
+/// // simulate popping off stack for single index
+/// let le = mono_st(&a, |x, y| x.lt(y));
+/// let mut seen_index = vec![0; n];
+/// for i in 0..n {
+///    let mut j = i.wrapping_sub(1);
+///    while j != le[i] {
+///       let range = le[j].wrapping_add(1)..j; // for all indexes k in range: !cmp(&a[k], &a[j])
+///       seen_index[j] += 1;
+///       j = le[j];
+///    }
+/// }
+///
+/// // clear the stack at the end
+/// let mut j = n.wrapping_sub(1);
+/// while j != usize::MAX {
+///    seen_index[j] += 1;
+///    j = le[j];
+/// }
+///
+/// assert_eq!(seen_index, vec![1; n]);
+/// ```
+///
+/// # Complexity
+/// - Time: O(n)
+/// - Space: O(n)
+pub fn mono_st<T: Ord, F: Fn(&T, &T) -> bool>(a: &[T], cmp: F) -> Vec<usize> {
+    let mut le = vec![0; a.len()];
+    for i in 0..a.len() {
+        le[i] = i.wrapping_sub(1);
+        while le[i] != usize::MAX && !cmp(&a[le[i]], &a[i]) {
+            le[i] = le[le[i]];
+        }
+    }
+    le
+}