Cartesian tree (#82)

* 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

* cartesian tree

* add indexes

---------

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

Author: lrvideckis

Cargo.toml

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

examples/monotonic/cartesian_tree.rs

@@ -0,0 +1,27 @@
+// verification-helper: PROBLEM https://judge.yosupo.jp/problem/cartesian_tree
+
+use proconio::input;
+use programming_team_code_rust::monotonic::cartesian_tree::cart_tree;
+use programming_team_code_rust::monotonic::mono_st::mono_st;
+
+fn main() {
+    input! {
+        n: usize,
+        a: [u32; n],
+    }
+    let le = mono_st(&a, |x, y| x.lt(y));
+    let p = cart_tree(&le);
+
+    println!(
+        "{}",
+        p.iter()
+            .enumerate()
+            .map(|(i, &x)| if x == usize::MAX {
+                i.to_string()
+            } else {
+                x.to_string()
+            })
+            .collect::<Vec<_>>()
+            .join(" ")
+    );
+}

src/monotonic/cartesian_tree.rs

@@ -0,0 +1,45 @@
+//! # Cartesian tree
+
+/// Gets Vec p where p\[i\] = parent of i in cartesian tree, or usize::MAX for root
+///
+////// # Example
+/// ```
+/// use programming_team_code_rust::monotonic::mono_st::mono_st;
+/// use programming_team_code_rust::monotonic::cartesian_tree::cart_tree;
+///
+/// // when cmp is lt:
+/// let a = [2, 1, 3, 1, 1, 0, 2, 2, 1, 0, 2];
+/// //      (---------------------------x---)
+/// //      (---------------x---------)   (x)
+/// //      (------------x) | (------x)    |
+/// //      (---------x)    | (---x) |     |
+/// //      (---x---)       | (x) |  |     |
+/// //      (x) | (x)       |  |  |  |     |
+/// //       |  |  |        |  |  |  |     |
+/// //       0  1  2  3  4  5  6  7  8  9  10
+///
+/// let le = mono_st(&a, |x, y| x.lt(y)); // lt -> right-most min is root
+/// let p = cart_tree(&le);               // le -> left-most min is root
+///                                       // gt -> right-most max is root
+///                                       // ge -> left-most max is root
+///
+/// assert_eq!(p, [1, 3, 1, 4, 5, 9, 7, 8, 5, usize::MAX, 9]);
+/// //             0  1  2  3  4  5  6  7  8  9           10
+/// ```
+///
+/// # Complexity
+/// - Time: O(n)
+/// - Space: O(n)
+pub fn cart_tree(le: &[usize]) -> Vec<usize> {
+    let mut p = le.to_vec();
+    for i in 0..p.len() {
+        let mut j = i.wrapping_sub(1);
+        while j != le[i] {
+            if le[j] == le[i] {
+                p[j] = i;
+            }
+            j = le[j];
+        }
+    }
+    p
+}

src/monotonic/mod.rs

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