Merge branch 'main' into compress_tree

Author: lrvideckis

Cargo.toml

@@ -211,3 +211,11 @@ path = "examples/monotonic/mono_st.rs"
 [[example]]
 name = "hld_aux_tree"
 path = "examples/graphs/hld_aux_tree.rs"
+
+[[example]]
+name = "count_rects"
+path = "examples/monotonic/count_rects.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(" ")
+    );
+}

examples/monotonic/count_rects.rs

@@ -0,0 +1,54 @@
+// verification-helper: PROBLEM https://onlinejudge.u-aizu.ac.jp/courses/library/7/DPL/all/DPL_3_B
+
+use proconio::input;
+use programming_team_code_rust::monotonic::count_rects::count_rects;
+
+fn main() {
+    input! {
+        n: usize,
+        m: usize,
+        grid: [[u32; m]; n],
+    }
+    let grid = grid
+        .iter()
+        .map(|row| row.iter().map(|&num| num == 0).collect::<Vec<_>>())
+        .collect::<Vec<_>>();
+    let cnt = count_rects(&grid);
+
+    {
+        let mut pref_sum = vec![vec![0; m + 1]; n + 1];
+        for i in 0..n {
+            for j in 0..m {
+                pref_sum[i + 1][j + 1] =
+                    grid[i][j] as i64 + pref_sum[i + 1][j] + pref_sum[i][j + 1] - pref_sum[i][j];
+            }
+        }
+        for len_i in 1..=5.min(n) {
+            for len_j in 1..5.min(m) {
+                let mut cnt_good_rects = 0;
+                for i in 0..=n - len_i {
+                    for j in 0..=m - len_j {
+                        let cnt_rect = pref_sum[i + len_i][j + len_j]
+                            - pref_sum[i + len_i][j]
+                            - pref_sum[i][j + len_j]
+                            + pref_sum[i][j];
+                        if cnt_rect == len_i as i64 * len_j as i64 {
+                            cnt_good_rects += 1;
+                        }
+                    }
+                }
+                assert_eq!(cnt_good_rects, cnt[len_i][len_j]);
+            }
+        }
+    }
+
+    let mut res = 0;
+    for (i, row) in cnt.iter().enumerate().skip(1) {
+        for (j, &num) in row.iter().enumerate().skip(1) {
+            if num > 0 {
+                res = res.max(i as u64 * j as u64);
+            }
+        }
+    }
+    println!("{}", res);
+}

src/data_structures/trie.rs

@@ -1,7 +1,7 @@
 //! # Trie
 
 const ALPHABET_SIZE: usize = 26;
-const FIRST_CHAR: char = 'A';
+const FIRST_CHAR: usize = 'A' as usize;
 
 #[derive(Default)]
 struct Node {
@@ -45,7 +45,7 @@ impl Trie {
     pub fn insert(&mut self, s: &[char]) {
         let mut v = 0;
         for &ch in s {
-            let idx = (ch as u8 - FIRST_CHAR as u8) as usize;
+            let idx = ch as usize - FIRST_CHAR;
             if self.t[v].next[idx].is_none() {
                 self.t[v].next[idx] = Some(self.t.len());
                 self.t.push(Node::default());
@@ -63,11 +63,12 @@ impl Trie {
     pub fn find(&self, s: &[char]) -> usize {
         let mut v = 0;
         for &ch in s {
-            let idx = (ch as u8 - FIRST_CHAR as u8) as usize;
-            if self.t[v].next[idx].is_none() {
+            let idx = ch as usize - FIRST_CHAR;
+            if let Some(u) = self.t[v].next[idx] {
+                v = u;
+            } else {
                 return 0;
             }
-            v = self.t[v].next[idx].unwrap();
         }
         self.t[v].cnt_words
     }

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/count_rects.rs

@@ -0,0 +1,65 @@
+//! # Count Rectangles
+
+use crate::monotonic::mono_range::mono_range;
+use crate::monotonic::mono_st::mono_st;
+
+/// grid is a n-by-m boolean array
+///
+/// Gets an (n+1)-by-(m+1) vec cnt where cnt\[i\]\[j\] = the number of times an i-by-j subrectangle
+/// appears in the grid such that all i*j cells in the subrectangle are true.
+///
+/// cnt\[i\]\[0\] and cnt\[0\]\[j\] will contain garbage numbers.
+///
+/// # Example
+/// ```
+/// use programming_team_code_rust::monotonic::count_rects::count_rects;
+///
+/// let mut cnt = count_rects(&[vec![true, true, false],
+///                             vec![true, true, true]]);
+///
+/// // remove garbage values
+/// cnt.drain(0..1);
+/// for i in 0..cnt.len() {
+///    cnt[i].drain(0..1);
+/// }
+///
+/// assert_eq!(cnt, [[5, 3, 1],
+///                  [2, 1, 0]]);
+///
+/// assert!(std::panic::catch_unwind(|| count_rects(&[])).is_err());
+/// ```
+///
+/// # Complexity
+/// - Time: O(nm)
+/// - Space: O(nm)
+pub fn count_rects(grid: &[Vec<bool>]) -> Vec<Vec<i32>> {
+    let (n, m) = (grid.len(), grid[0].len());
+    let mut cnt = vec![vec![0; m + 1]; n + 1];
+    let mut h = vec![0; m];
+    for row in grid {
+        for j in 0..m {
+            h[j] = row[j] as usize * (h[j] + 1);
+        }
+        let le = mono_st(&h, |x, y| x.lt(y));
+        let ri = mono_range(&le);
+        for j in 0..m {
+            let (cnt_l, cnt_r) = (j - le[j].wrapping_add(1), ri[j] - j - 1);
+            cnt[h[j]][cnt_l + cnt_r + 1] += 1;
+            cnt[h[j]][cnt_l] -= 1;
+            cnt[h[j]][cnt_r] -= 1;
+        }
+    }
+    for row in cnt.iter_mut().skip(1) {
+        for _ in 0..2 {
+            for j in (1..m).rev() {
+                row[j] += row[j + 1];
+            }
+        }
+    }
+    for i in (1..n).rev() {
+        for j in 1..=m {
+            cnt[i][j] += cnt[i + 1][j];
+        }
+    }
+    cnt
+}

src/monotonic/mod.rs

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