Range container (#87)

* saving progress

* finish insert

* rename

* finished impl

* finished test, need to fix some bugs tho

* saving progress

* ACs!!!

* progress

* fix clippy

* fix nit

* clean

* rename

* nit

* nit

* another nit

* better var names

* more nits

* finished docs

* rename

* raname

* wording nit

* nit

* nits

* saving progress

* another assert

* fix clippy

* nit

* correct doc

* switch stress to handmade

* change readme too

* switch to templatizing

---------

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

Author: lrvideckis

Cargo.toml

@@ -201,8 +201,16 @@ name = "lis_yosupo"
 path = "examples/helpers/lis_yosupo.rs"
 
 [[example]]
-name = "lis_pop"
-path = "examples/helpers/lis_pop.rs"
+name = "lis_handmade"
+path = "examples/helpers/lis_handmade.rs"
+
+[[example]]
+name = "range_container_aizu"
+path = "examples/helpers/range_container_aizu.rs"
+
+[[example]]
+name = "range_container_handmade"
+path = "examples/helpers/range_container_handmade.rs"
 
 [[example]]
 name = "mono_st"
@@ -226,4 +234,4 @@ path = "examples/data_structures/disjoint_rmq_non_commutative.rs"
 
 [[example]]
 name = "lca_rmq_next_on_path"
-path = "examples/graphs/lca_rmq_next_on_path.rs"
+path = "examples/graphs/lca_rmq_next_on_path.rs"

examples/README.md

@@ -2,6 +2,7 @@
 - tests are named `[algo].rs`
 - use both yosupo and aizu to test whenever possible because bugs have existed on one of the sites but not the other
 - when using both sites name the files `[algo]_yosupo.rs` and `[algo]_aizu.rs`
+- when there's no problem to test on, test on [hello world](https://onlinejudge.u-aizu.ac.jp/courses/lesson/2/ITP1/all/ITP1_1_A) and name the files `[algo]_handmade.rs`
 - when only testing a specific function or componenet of some algorithm name the file `[algo]_[component].rs`
 
 # Documentation Guidelines

examples/helpers/lis_pop.rs examples/helpers/lis_handmade.rsexamples/helpers/lis_pop.rs renamed to examples/helpers/lis_handmade.rs

@@ -1,6 +1,7 @@
 // verification-helper: PROBLEM https://onlinejudge.u-aizu.ac.jp/courses/lesson/2/ITP1/all/ITP1_1_A
 
 use programming_team_code_rust::helpers::lis::Lis;
+use rand::{thread_rng, Rng};
 
 fn lis_quadratic(a: &[i32]) -> usize {
     let n = a.len();
@@ -19,13 +20,14 @@ fn lis_quadratic(a: &[i32]) -> usize {
 }
 
 fn main() {
+    let mut rng = thread_rng();
     for _ in 0..100 {
         let mut lis = Lis::default();
         let mut a = Vec::new();
         for _ in 0..1000 {
-            match rand::random::<u8>() % 3 {
+            match rng.gen_range(0..3) {
                 0 => {
-                    let new_num = rand::random::<i32>();
+                    let new_num = rng.r#gen();
                     lis.push(new_num);
                     a.push(new_num);
                 }

examples/helpers/range_container_aizu.rs

@@ -0,0 +1,45 @@
+// verification-helper: PROBLEM https://onlinejudge.u-aizu.ac.jp/problems/DSL_2_D
+
+use proconio::input;
+use programming_team_code_rust::helpers::range_container::RangeContainer;
+
+fn main() {
+    input! {
+        n: usize,
+        q: usize,
+    }
+    let mut rc = RangeContainer::default();
+    let mut to_value = vec![i32::MAX; 2 * n + 2];
+    rc.insert_range(0..(2 * n + 1) as i32);
+
+    for _ in 0..q {
+        input! {
+            kind: usize,
+        }
+        match kind {
+            0 => {
+                input! {
+                    le: i32,
+                    ri: i32,
+                    x: i32,
+                }
+                let le = 2 * le;
+                let ri = 2 * ri;
+                let save_range = rc.get_range(ri + 2).unwrap();
+                let save_value = to_value[save_range.start as usize];
+                rc.remove_range(le - 1..ri + 2);
+                rc.insert_range(le..ri + 1);
+                let save_range = rc.get_range(ri + 2).unwrap();
+                to_value[save_range.start as usize] = save_value;
+                to_value[le as usize] = x;
+            }
+            _ => {
+                input! {
+                    index: i32,
+                }
+                let range_containing = rc.get_range(2 * index).unwrap();
+                println!("{}", to_value[range_containing.start as usize]);
+            }
+        }
+    }
+}

examples/helpers/range_container_handmade.rs

@@ -0,0 +1,65 @@
+// verification-helper: PROBLEM https://onlinejudge.u-aizu.ac.jp/courses/lesson/2/ITP1/all/ITP1_1_A
+
+use programming_team_code_rust::helpers::range_container::RangeContainer;
+use rand::{thread_rng, Rng};
+use std::collections::BTreeMap;
+
+fn main() {
+    let mut rng = thread_rng();
+    for _ in 0..100 {
+        let max_n = rng.gen_range(1..100);
+        let mut vis = vec![false; max_n + 1];
+        let mut rc = RangeContainer::default();
+        for _ in 0..100 {
+            let mut le = rng.gen_range(0..max_n);
+            let mut ri = rng.gen_range(0..max_n);
+            if le > ri {
+                (le, ri) = (ri, le);
+            }
+            ri += 1;
+            match rng.gen_range(0..2) {
+                0 => {
+                    rc.insert_range(le as i32..ri as i32);
+                    for elem in vis.iter_mut().take(ri).skip(le) {
+                        *elem = true;
+                    }
+                }
+                _ => {
+                    rc.remove_range(le as i32..ri as i32);
+                    for elem in vis.iter_mut().take(ri).skip(le) {
+                        *elem = false;
+                    }
+                }
+            }
+            let mut to_end = vec![None; max_n + 1];
+            for i in (0..max_n).rev() {
+                if vis[i] && !vis[i + 1] {
+                    to_end[i] = Some(i + 1);
+                } else if vis[i] {
+                    to_end[i] = to_end[i + 1];
+                }
+            }
+            let mut naive_mp = BTreeMap::<i32, i32>::new();
+            let mut start = None;
+            for i in 0..max_n + 1 {
+                if vis[i] {
+                    if start.is_none() {
+                        start = Some(i);
+                    }
+                    assert_eq!(
+                        rc.get_range(i as i32).unwrap(),
+                        start.unwrap() as i32..to_end[i].unwrap() as i32
+                    );
+                } else {
+                    assert_eq!(rc.get_range(i as i32), None);
+                    if let Some(curr_start) = start {
+                        naive_mp.insert(curr_start as i32, i as i32);
+                    }
+                    start = None;
+                }
+            }
+            assert_eq!(rc.mp, naive_mp);
+        }
+    }
+    println!("Hello World");
+}

src/helpers/mod.rs

@@ -1,4 +1,5 @@
 //! # Helpers
 pub mod compress;
 pub mod lis;
+pub mod range_container;
 pub mod unsafe_recursive_closure;

src/helpers/range_container.rs

@@ -0,0 +1,92 @@
+//! # Range Container
+
+use std::collections::BTreeMap;
+use std::ops::Range;
+
+/// # Example
+/// ```
+/// use programming_team_code_rust::helpers::range_container::RangeContainer;
+///
+/// let mut rc = RangeContainer::default();
+/// rc.insert_range(-2..2);
+/// rc.insert_range(2..3);
+/// assert_eq!(rc.get_range(0), Some(-2..3));
+/// assert_eq!(rc.get_range(3), None);
+/// rc.remove_range(-1..1);
+///
+/// assert_eq!(rc.get_range(-2), Some(-2..-1));
+/// assert_eq!(rc.get_range(2), Some(1..3));
+/// ```
+#[derive(Default)]
+pub struct RangeContainer<T> {
+    /// an entry le -> ri represents a range [le, ri)
+    /// invariant: previous_ri < current_le
+    pub mp: BTreeMap<T, T>,
+}
+
+impl<T: Copy + Ord> RangeContainer<T> {
+    fn remove(&mut self, range: &Range<T>) -> Option<T> {
+        let mut last_ri = None;
+        for (le, ri) in self
+            .mp
+            .range(range.start..=range.end)
+            .map(|(&le, &ri)| (le, ri))
+            .collect::<Vec<_>>()
+        {
+            self.mp.remove(&le);
+            last_ri = Some(ri);
+        }
+        last_ri
+    }
+
+    /// Inserts a range into the container
+    ///
+    /// # Complexity
+    /// - Time: O(log n) ammortized
+    /// - Space: O(1) ammortized
+    pub fn insert_range(&mut self, mut range: Range<T>) {
+        if let Some(last_ri) = self.remove(&range) {
+            range.end = std::cmp::max(range.end, last_ri);
+        }
+        if let Some((_, ri)) = self.mp.range_mut(..range.start).next_back() {
+            if *ri >= range.start {
+                *ri = std::cmp::max(*ri, range.end);
+                return;
+            }
+        }
+        self.mp.insert(range.start, range.end);
+    }
+
+    /// Removes a range from the container
+    ///
+    /// # Complexity
+    /// - Time: O(log n) ammortized
+    /// - Space: O(1) ammortized
+    pub fn remove_range(&mut self, range: Range<T>) {
+        if let Some(last_ri) = self.remove(&range) {
+            if range.end < last_ri {
+                self.mp.insert(range.end, last_ri);
+            }
+        }
+        if let Some((_, ri)) = self.mp.range_mut(..range.start).next_back() {
+            let ri = std::mem::replace(ri, std::cmp::min(*ri, range.start));
+            if range.end < ri {
+                self.mp.insert(range.end, ri);
+            }
+        }
+    }
+
+    /// Gets range containing idx
+    ///
+    /// # Complexity
+    /// - Time: O(log n)
+    /// - Space: O(1)
+    pub fn get_range(&self, idx: T) -> Option<Range<T>> {
+        if let Some((&le, &ri)) = self.mp.range(..=idx).next_back() {
+            if idx < ri {
+                return Some(le..ri);
+            }
+        }
+        None
+    }
+}