Implement Lazy Segtree

examples/practice2_j_segment_tree.rs

@@ -0,0 +1,35 @@
+use ac_library_rs::{Max, Segtree};
+use std::io::Read;
+
+fn main() {
+    let mut buf = String::new();
+    std::io::stdin().read_to_string(&mut buf).unwrap();
+    let mut input = buf.split_whitespace();
+
+    let n: usize = input.next().unwrap().parse().unwrap();
+    let q: usize = input.next().unwrap().parse().unwrap();
+    let mut segtree = Segtree::<Max<i32>>::new(n + 1);
+    for i in 1..=n {
+        segtree.set(i, input.next().unwrap().parse().unwrap());
+    }
+    for _ in 0..q {
+        match input.next().unwrap().parse().unwrap() {
+            1 => {
+                let x = input.next().unwrap().parse().unwrap();
+                let v = input.next().unwrap().parse().unwrap();
+                segtree.set(x, v);
+            }
+            2 => {
+                let l = input.next().unwrap().parse().unwrap();
+                let r: usize = input.next().unwrap().parse().unwrap();
+                println!("{}", segtree.prod(l, r + 1));
+            }
+            3 => {
+                let x = input.next().unwrap().parse().unwrap();
+                let v = input.next().unwrap().parse().unwrap();
+                println!("{}", segtree.max_right(x, |a| a < &v))
+            }
+            _ => {}
+        }
+    }
+}

examples/practice2_k_range_affine_range_sum.rs

@@ -0,0 +1,67 @@
+use ac_library_rs::{LazySegtree, MapMonoid, ModInt998244353, Monoid};
+use std::io::Read;
+
+type Mint = ModInt998244353;
+struct Sum;
+impl Monoid for Sum {
+    type S = (Mint, usize);
+
+    fn identity() -> Self::S {
+        (0.into(), 0)
+    }
+
+    fn binary_operation(&(a, n): &Self::S, &(b, m): &Self::S) -> Self::S {
+        (a + b, n + m)
+    }
+}
+struct Affine;
+impl MapMonoid for Affine {
+    type M = Sum;
+    type F = (Mint, Mint);
+
+    fn identity_map() -> Self::F {
+        (1.into(), 0.into())
+    }
+
+    fn mapping(&(a, b): &Self::F, &(x, n): &<Self::M as Monoid>::S) -> <Self::M as Monoid>::S {
+        (a * x + b * Mint::new(n), n)
+    }
+
+    // a(cx + d) + b = (ac)x + (ad+b)
+    fn composition(&(a, b): &Self::F, &(c, d): &Self::F) -> Self::F {
+        (a * c, a * d + b)
+    }
+}
+
+#[allow(clippy::many_single_char_names)]
+fn main() {
+    let mut buf = String::new();
+    std::io::stdin().read_to_string(&mut buf).unwrap();
+    let mut input = buf.split_whitespace();
+
+    let n = input.next().unwrap().parse().unwrap();
+    let q = input.next().unwrap().parse().unwrap();
+    let mut segtree: LazySegtree<Affine> = input
+        .by_ref()
+        .take(n)
+        .map(|s| (s.parse().unwrap(), 1))
+        .collect::<Vec<_>>()
+        .into();
+    for _ in 0..q {
+        match input.next().unwrap().parse().unwrap() {
+            0 => {
+                let l = input.next().unwrap().parse().unwrap();
+                let r = input.next().unwrap().parse().unwrap();
+                let b = input.next().unwrap().parse().unwrap();
+                let c = input.next().unwrap().parse().unwrap();
+                segtree.apply_range(l, r, (b, c));
+            }
+            1 => {
+                let l = input.next().unwrap().parse().unwrap();
+                let r = input.next().unwrap().parse().unwrap();
+                println!("{}", segtree.prod(l, r).0);
+            }
+            _ => {}
+        }
+    }
+}

examples/practice2_l_lazy_segment_tree.rs

@@ -0,0 +1,63 @@
+#![allow(clippy::many_single_char_names)]
+use ac_library_rs::{LazySegtree, MapMonoid, Monoid};
+use std::io::Read;
+use std::iter;
+
+struct M;
+impl Monoid for M {
+    type S = (u64, u64, u64);
+    fn identity() -> Self::S {
+        (0, 0, 0)
+    }
+    fn binary_operation(&(a, b, c): &Self::S, &(d, e, f): &Self::S) -> Self::S {
+        (a + d, b + e, c + f + b * d)
+    }
+}
+struct F;
+impl MapMonoid for F {
+    type M = M;
+    type F = bool;
+
+    fn identity_map() -> Self::F {
+        false
+    }
+    fn mapping(&f: &Self::F, &(a, b, c): &<M as Monoid>::S) -> <M as Monoid>::S {
+        if f {
+            // (a + b) * (a + b - 1) / 2 - a * (a - 1) / 2 - b * (b - 1) / 2 - c
+            // = a * b - c
+            (b, a, a * b - c)
+        } else {
+            (a, b, c)
+        }
+    }
+    fn composition(&f: &Self::F, &g: &Self::F) -> Self::F {
+        f ^ g
+    }
+}
+
+fn main() {
+    let mut buf = String::new();
+    std::io::stdin().read_to_string(&mut buf).unwrap();
+    let mut input = buf.split_whitespace();
+
+    let n = input.next().unwrap().parse().unwrap();
+    let q = input.next().unwrap().parse().unwrap();
+    let mut segtree: LazySegtree<F> = iter::once((0, 0, 0))
+        .chain(input.by_ref().take(n).map(|s| match s {
+            "0" => (1, 0, 0),
+            "1" => (0, 1, 0),
+            _ => panic!(),
+        }))
+        .collect::<Vec<_>>()
+        .into();
+    for _ in 0..q {
+        let t = input.next().unwrap().parse().unwrap();
+        let l = input.next().unwrap().parse().unwrap();
+        let r: usize = input.next().unwrap().parse().unwrap();
+        match t {
+            1 => segtree.apply_range(l, r + 1, true),
+            2 => println!("{}", segtree.prod(l, r + 1).2),
+            _ => {}
+        }
+    }
+}

src/internal_type_traits.rs

@@ -52,37 +52,65 @@ pub trait Integral:
     + fmt::Debug
     + fmt::Binary
     + fmt::Octal
+    + Zero
+    + One
+    + BoundedBelow
+    + BoundedAbove
 {
+}
+
+/// Class that has additive identity element
+pub trait Zero {
+    /// The additive identity element
     fn zero() -> Self;
+}
+
+/// Class that has multiplicative identity element
+pub trait One {
+    /// The multiplicative identity element
     fn one() -> Self;
+}
+
+pub trait BoundedBelow {
     fn min_value() -> Self;
+}
+
+pub trait BoundedAbove {
     fn max_value() -> Self;
 }
 
 macro_rules! impl_integral {
     ($($ty:ty),*) => {
         $(
-            impl Integral for $ty {
+            impl Zero for $ty {
                 #[inline]
                 fn zero() -> Self {
                     0
                 }
+            }
 
+            impl One for $ty {
                 #[inline]
                 fn one() -> Self {
                     1
                 }
+            }
 
+            impl BoundedBelow for $ty {
                 #[inline]
                 fn min_value() -> Self {
                     Self::min_value()
                 }
+            }
 
+            impl BoundedAbove for $ty {
                 #[inline]
                 fn max_value() -> Self {
                     Self::max_value()
                 }
             }
+
+            impl Integral for $ty {}
         )*
     };
 }