Disjoint rmq (#92)

* start of DJ RMQ

* first draft of disjoint rmq

* golf

* finish docs

* Update disjoint_rmq.rs

* Update disjoint_rmq.rs

* nit

* update example

* nits

---------

Co-authored-by: Luke Videckis <lukevideckis@gmail.com>
Co-authored-by: Cameron Custer <73217097+cameroncuster@users.noreply.github.com>

Author: lrvideckis

Cargo.toml

@@ -216,6 +216,10 @@ path = "examples/monotonic/count_rects.rs"
 name = "cartesian_tree"
 path = "examples/monotonic/cartesian_tree.rs"
 
+[[example]]
+name = "disjoint_rmq_non_commutative"
+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/data_structures/disjoint_rmq_non_commutative.rs

@@ -0,0 +1,51 @@
+// verification-helper: PROBLEM https://judge.yosupo.jp/problem/queue_operate_all_composite
+
+use proconio::input;
+use programming_team_code_rust::data_structures::disjoint_rmq::DisjointRMQ;
+
+const MOD: u64 = 998_244_353;
+
+fn main() {
+    input! {
+        q: usize,
+    }
+
+    let mut que = Vec::new();
+    let mut front = 0;
+    let mut queries = Vec::new();
+
+    for _ in 0..q {
+        input! {
+            t: u8,
+        }
+        match t {
+            0 => {
+                input! {
+                    a: u64,
+                    b: u64,
+                }
+                que.push((a, b));
+            }
+            1 => {
+                front += 1;
+            }
+            _ => {
+                input! {
+                    x: u64,
+                }
+                queries.push((front..que.len(), x));
+            }
+        }
+    }
+
+    let d_rmq = DisjointRMQ::new(&que, |&a, &b| (a.0 * b.0 % MOD, (b.0 * a.1 + b.1) % MOD));
+
+    for (range, x) in queries {
+        if range.is_empty() {
+            println!("{}", x);
+        } else {
+            let (slope, y_int) = d_rmq.query(range);
+            println!("{}", (slope * x + y_int) % MOD);
+        }
+    }
+}

src/data_structures/disjoint_rmq.rs

@@ -0,0 +1,68 @@
+//! # Disjoint Range Minimum Query
+
+/// # Example
+/// ```
+/// use programming_team_code_rust::data_structures::disjoint_rmq::DisjointRMQ;
+///
+/// let a = [1, 3, 1, 4, 5];
+/// // (min, number of mins)
+/// let rmq = DisjointRMQ::new(&a.iter().map(|&x| (x, 1)).collect::<Vec<_>>(), |&x, &y| {
+///    if x.0 == y.0 {
+///       (x.0, x.1 + y.1)
+///    } else {
+///       std::cmp::min(x, y)
+///    }
+/// });
+/// assert_eq!(rmq.query(0..5), (1, 2));
+/// assert_eq!(rmq.query(3..5), (4, 1));
+/// assert!(std::panic::catch_unwind(|| rmq.query(1..1)).is_err());
+/// ```
+pub struct DisjointRMQ<T, F> {
+    t: Vec<Vec<T>>,
+    op: F,
+}
+
+impl<T: Clone, F: Fn(&T, &T) -> T> DisjointRMQ<T, F> {
+    /// Create a new Disjoint RMQ instance
+    ///
+    /// # Complexity (n = a.len())
+    /// - Time: O(n log n)
+    /// - Space: O(n log n)
+    pub fn new(a: &[T], op: F) -> Self {
+        let mut t = vec![];
+        let mut len = 1;
+        while len <= a.len() {
+            let mut le = 0;
+            let mut row = a.to_vec();
+            while le < a.len() {
+                let mi = (le + len).min(a.len());
+                let ri = (le + 2 * len).min(a.len());
+                for i in (le..mi - 1).rev() {
+                    row[i] = op(&row[i], &row[i + 1]);
+                }
+                for i in mi + 1..ri {
+                    row[i] = op(&row[i - 1], &row[i]);
+                }
+                le += 2 * len;
+            }
+            t.push(row);
+            len *= 2;
+        }
+        Self { t, op }
+    }
+
+    /// Query the range [range.start, range.end)
+    ///
+    /// # Complexity
+    /// - Time: O(1)
+    /// - Space: O(1)
+    pub fn query(&self, range: std::ops::Range<usize>) -> T {
+        assert!(!range.is_empty());
+        if range.len() == 1 {
+            self.t[0][range.start].clone()
+        } else {
+            let lg = (range.start ^ (range.end - 1)).ilog2() as usize;
+            (self.op)(&self.t[lg][range.start], &self.t[lg][range.end - 1])
+        }
+    }
+}

src/data_structures/mod.rs

@@ -1,5 +1,6 @@
 //! # Data Structures
 pub mod binary_trie;
+pub mod disjoint_rmq;
 pub mod fenwick;
 pub mod lazy_seg_tree;
 pub mod rmq;