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

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 {
        scan!(scanner, 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 } => {
                writeln!(writer, "{}", seg.fold(l..r).sum).ok();
            }
        }
    }
}

pub fn chmax(x: T) -> Self

Examples found in repository

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

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 {
        scan!(scanner, 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 } => {
                writeln!(writer, "{}", seg.fold(l..r).sum).ok();
            }
        }
    }
}

pub fn add(x: T) -> Self

Examples found in repository

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

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 {
        scan!(scanner, 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 } => {
                writeln!(writer, "{}", seg.fold(l..r).sum).ok();
            }
        }
    }
}

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

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

impl<T> StructuralPartialEq for RangeChminChmaxAdd<T>