Struct SeekByRaccCond 

pub struct SeekByRaccCond<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> SeekByRaccCond<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 447)

    pub fn find_by_racc_cond<F>(&mut self, f: F) -> Option<BstNodeId<TreapSpec<M, L>>>
    where
        F: FnMut(&L::Agg) -> bool,
    {
        let split = Split::new(
            &mut self.root,
            SeekByRaccCond::<TreapSpec<M, L>, L, F>::new(f),
            EqualSide::Left,
        );
        let node = split.left()?.rightmost();
        self.node_id_manager.registered_node_id(node)
    }

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

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

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

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

Trait Implementations

impl<Spec, L, F> BstSeeker for SeekByRaccCond<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