Struct RangeChminChmaxAdd 

pub struct RangeChminChmaxAdd<T> {
    lb: T,
    ub: T,
    bias: T,
}

Fields

lb: T

ub: T

bias: T

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 26)

pub fn range_chmin_chmax_add_range_sum(reader: impl Read, writer: impl Write) {
    prepare_io!(reader, writer);
    sc!(n, q, a: [Saturating<i64>; iter n]);
    let mut seg = LazySegmentTree::<RangeSumRangeChminChmaxAdd<Saturating<i64>>>::from_keys(a);
    for _ in 0..q {
        sc!(query: Query);
        match query {
            Query::Chmin { l, r, b } => {
                seg.update(l..r, RangeChminChmaxAdd::chmin(b));
            }
            Query::Chmax { l, r, b } => {
                seg.update(l..r, RangeChminChmaxAdd::chmax(b));
            }
            Query::Add { l, r, b } => {
                seg.update(l..r, RangeChminChmaxAdd::add(b));
            }
            Query::Sum { l, r } => {
                pp!(seg.fold(l..r).sum);
            }
        }
    }
}

pub fn chmax(x: T) -> Self

Examples found in repository

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

pub fn range_chmin_chmax_add_range_sum(reader: impl Read, writer: impl Write) {
    prepare_io!(reader, writer);
    sc!(n, q, a: [Saturating<i64>; iter n]);
    let mut seg = LazySegmentTree::<RangeSumRangeChminChmaxAdd<Saturating<i64>>>::from_keys(a);
    for _ in 0..q {
        sc!(query: Query);
        match query {
            Query::Chmin { l, r, b } => {
                seg.update(l..r, RangeChminChmaxAdd::chmin(b));
            }
            Query::Chmax { l, r, b } => {
                seg.update(l..r, RangeChminChmaxAdd::chmax(b));
            }
            Query::Add { l, r, b } => {
                seg.update(l..r, RangeChminChmaxAdd::add(b));
            }
            Query::Sum { l, r } => {
                pp!(seg.fold(l..r).sum);
            }
        }
    }
}

pub fn add(x: T) -> Self

Examples found in repository

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

pub fn range_chmin_chmax_add_range_sum(reader: impl Read, writer: impl Write) {
    prepare_io!(reader, writer);
    sc!(n, q, a: [Saturating<i64>; iter n]);
    let mut seg = LazySegmentTree::<RangeSumRangeChminChmaxAdd<Saturating<i64>>>::from_keys(a);
    for _ in 0..q {
        sc!(query: Query);
        match query {
            Query::Chmin { l, r, b } => {
                seg.update(l..r, RangeChminChmaxAdd::chmin(b));
            }
            Query::Chmax { l, r, b } => {
                seg.update(l..r, RangeChminChmaxAdd::chmax(b));
            }
            Query::Add { l, r, b } => {
                seg.update(l..r, RangeChminChmaxAdd::add(b));
            }
            Query::Sum { l, r } => {
                pp!(seg.fold(l..r).sum);
            }
        }
    }
}

Trait Implementations

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: Clone> Clone for RangeChminChmaxAdd<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for RangeChminChmaxAdd<T>

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

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

Formats the value using the given formatter.

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

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> MonoidAct for RangeChminChmaxAdd<T>

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

type Key = T

type Act = RangeChminChmaxAdd<T>

type ActMonoid = RangeChminChmaxAdd<T>

fn act(x: &Self::Key, a: &Self::Act) -> Self::Key

fn act_assign(x: &mut Self::Key, a: &Self::Act)

fn unit() -> Self::Act

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

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

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

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

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

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::T: PartialEq,

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