Struct RangeChminChmaxAdd 

pub struct RangeChminChmaxAdd<T> { /* private fields */ }

Implementations

impl<T> RangeChminChmaxAdd<T>

where T: Zero + Bounded,

pub fn chmin(x: T) -> Self

Examples found in repository

crates/library_checker/src/data_structure/range_chmin_chmax_add_range_sum.rs (line 23)

pub fn range_chmin_chmax_add_range_sum(reader: impl Read, mut writer: impl Write) {
    let s = read_all_unchecked(reader);
    let mut scanner = Scanner::new(&s);
    scan!(scanner, n, q, a: [Saturating<i64>; n]);
    let mut seg = LazySegmentTree::<RangeSumRangeChminChmaxAdd<Saturating<i64>>>::from_vec(
        a.iter()
            .map(|&a| RangeSumRangeChminChmaxAdd::single(a, Saturating(1)))
            .collect(),
    );
    for _ in 0..q {
        match scanner.scan::<usize>() {
            0 => {
                scan!(scanner, l, r, b: Saturating<i64>);
                seg.update(l..r, RangeChminChmaxAdd::chmin(b));
            }
            1 => {
                scan!(scanner, l, r, b: Saturating<i64>);
                seg.update(l..r, RangeChminChmaxAdd::chmax(b));
            }
            2 => {
                scan!(scanner, l, r, b: Saturating<i64>);
                seg.update(l..r, RangeChminChmaxAdd::add(b));
            }
            3 => {
                scan!(scanner, l, r);
                writeln!(writer, "{}", seg.fold(l..r).sum).ok();
            }
            _ => panic!("unknown query"),
        }
    }
}

pub fn chmax(x: T) -> Self

Examples found in repository

crates/library_checker/src/data_structure/range_chmin_chmax_add_range_sum.rs (line 27)

pub fn range_chmin_chmax_add_range_sum(reader: impl Read, mut writer: impl Write) {
    let s = read_all_unchecked(reader);
    let mut scanner = Scanner::new(&s);
    scan!(scanner, n, q, a: [Saturating<i64>; n]);
    let mut seg = LazySegmentTree::<RangeSumRangeChminChmaxAdd<Saturating<i64>>>::from_vec(
        a.iter()
            .map(|&a| RangeSumRangeChminChmaxAdd::single(a, Saturating(1)))
            .collect(),
    );
    for _ in 0..q {
        match scanner.scan::<usize>() {
            0 => {
                scan!(scanner, l, r, b: Saturating<i64>);
                seg.update(l..r, RangeChminChmaxAdd::chmin(b));
            }
            1 => {
                scan!(scanner, l, r, b: Saturating<i64>);
                seg.update(l..r, RangeChminChmaxAdd::chmax(b));
            }
            2 => {
                scan!(scanner, l, r, b: Saturating<i64>);
                seg.update(l..r, RangeChminChmaxAdd::add(b));
            }
            3 => {
                scan!(scanner, l, r);
                writeln!(writer, "{}", seg.fold(l..r).sum).ok();
            }
            _ => panic!("unknown query"),
        }
    }
}

pub fn add(x: T) -> Self

Examples found in repository

crates/library_checker/src/data_structure/range_chmin_chmax_add_range_sum.rs (line 31)

pub fn range_chmin_chmax_add_range_sum(reader: impl Read, mut writer: impl Write) {
    let s = read_all_unchecked(reader);
    let mut scanner = Scanner::new(&s);
    scan!(scanner, n, q, a: [Saturating<i64>; n]);
    let mut seg = LazySegmentTree::<RangeSumRangeChminChmaxAdd<Saturating<i64>>>::from_vec(
        a.iter()
            .map(|&a| RangeSumRangeChminChmaxAdd::single(a, Saturating(1)))
            .collect(),
    );
    for _ in 0..q {
        match scanner.scan::<usize>() {
            0 => {
                scan!(scanner, l, r, b: Saturating<i64>);
                seg.update(l..r, RangeChminChmaxAdd::chmin(b));
            }
            1 => {
                scan!(scanner, l, r, b: Saturating<i64>);
                seg.update(l..r, RangeChminChmaxAdd::chmax(b));
            }
            2 => {
                scan!(scanner, l, r, b: Saturating<i64>);
                seg.update(l..r, RangeChminChmaxAdd::add(b));
            }
            3 => {
                scan!(scanner, l, r);
                writeln!(writer, "{}", seg.fold(l..r).sum).ok();
            }
            _ => panic!("unknown query"),
        }
    }
}

Trait Implementations

impl<T: Clone> Clone for RangeChminChmaxAdd<T>

fn clone(&self) -> RangeChminChmaxAdd<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for RangeChminChmaxAdd<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Magma for RangeChminChmaxAdd<T>

where T: Copy + Zero + One + Ord + Bounded + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + PartialEq,

type T = RangeChminChmaxAdd<T>

type of operands: $T$

fn operate(x: &Self::T, y: &Self::T) -> Self::T

binary operaion: $\circ$

fn reverse_operate(x: &Self::T, y: &Self::T) -> Self::T

fn operate_assign(x: &mut Self::T, y: &Self::T)

impl<T: PartialEq> PartialEq for RangeChminChmaxAdd<T>

fn eq(&self, other: &RangeChminChmaxAdd<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Unital for RangeChminChmaxAdd<T>

where T: Copy + Zero + One + Ord + Bounded + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + PartialEq,

fn unit() -> Self::T

identity element: $e$

fn is_unit(x: &Self::T) -> bool

where <Self as Magma>::T: PartialEq,

fn set_unit(x: &mut Self::T)

impl<T> Associative for RangeChminChmaxAdd<T>

where T: Copy + Zero + One + Ord + Bounded + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + PartialEq,

impl<T: Eq> Eq for RangeChminChmaxAdd<T>

impl<T> StructuralPartialEq for RangeChminChmaxAdd<T>