Struct SeekByAccCond 

pub struct SeekByAccCond<Spec, L, F>
where
    L: LazyMapMonoid,
{
    acc: L::Agg,
    f: F,
    _marker: PhantomData<fn() -> (Spec, L)>,
}

Fields

acc: L::Agg

f: F

_marker: PhantomData<fn() -> (Spec, L)>

Implementations

impl<Spec, L, F> SeekByAccCond<Spec, L, F>

where L: LazyMapMonoid, F: FnMut(&L::Agg) -> bool,

pub fn new(f: F) -> Self

Examples found in repository

crates/competitive/src/data_structure/treap.rs (line 434)

    pub fn find_by_acc_cond<F>(&mut self, f: F) -> Option<BstNodeId<TreapSpec<M, L>>>
    where
        F: FnMut(&L::Agg) -> bool,
    {
        let split = Split::new(
            &mut self.root,
            SeekByAccCond::<TreapSpec<M, L>, L, F>::new(f),
            EqualSide::Right,
        );
        let node = split.right()?.leftmost();
        self.node_id_manager.registered_node_id(node)
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 369)

    pub fn partition_point_acc<F>(&mut self, left: usize, mut pred: F) -> usize
    where
        F: FnMut(&T::Agg) -> bool,
    {
        let mut split3 = Split3::seek_by_size(&mut self.root, left..);
        let front_size = split3
            .left()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        let split = split3.split_mid(SeekByAccCond::new(|acc| !pred(acc)), EqualSide::Right);
        let index = split
            .left()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        front_size + index
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 473)

    pub fn partition_point_acc<F>(&mut self, left: usize, mut pred: F) -> usize
    where
        F: FnMut(&T::Agg) -> bool,
    {
        let mut split3 = Split3::seek_by_size(&mut self.root, left..);
        let front_size = split3
            .left()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        let split = split3.split_mid(SeekByAccCond::new(|acc| !pred(acc)), EqualSide::Right);
        let index = split
            .left()
            .map(|node| node.into_data().size)
            .unwrap_or_default();
        front_size + index
    }

Trait Implementations

impl<Spec, L, F> BstSeeker for SeekByAccCond<Spec, L, F>

where Spec: BstSpec<Data: BstDataAccess<LazyMap, Value = LazyMapElement<L>>>, L: LazyMapMonoid, F: FnMut(&L::Agg) -> bool,

type Spec = Spec

fn bst_seek(&mut self, node: BstImmutRef<'_, Self::Spec>) -> Ordering