Count rects (#81)

* 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

* count rects

* fix clippy

* beef up test

* finish docs

* fix doc

* shorten

* nit to docs

* now ACs

* format

* nit

* nits

* nit

* nit

---------

Co-authored-by: Luke Videckis <[email protected]>

Author: lrvideckis

Cargo.toml

@@ -208,6 +208,10 @@ path = "examples/helpers/lis_pop.rs"
 name = "mono_st"
 path = "examples/monotonic/mono_st.rs"
 
+[[example]]
+name = "count_rects"
+path = "examples/monotonic/count_rects.rs"
+
 [[example]]
 name = "cartesian_tree"
 path = "examples/monotonic/cartesian_tree.rs"

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/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,4 +1,5 @@
 //! # Monotonic
 pub mod cartesian_tree;
+pub mod count_rects;
 pub mod mono_range;
 pub mod mono_st;