Struct PartisanGameAnalyzer 

pub struct PartisanGameAnalyzer<G>
where
    G: PartisanGame<State: Eq + Hash>,
{
    game: G,
    number: HashMap<G::State, i64>,
}

Fields

game: G

number: HashMap<G::State, i64>

Implementations

impl<G> PartisanGameAnalyzer<G>

where G: PartisanGame<State: Eq + Hash + Clone>,

pub fn new(game: G) -> Self

pub fn eval(&mut self, s: &G::State) -> i64

Examples found in repository

crates/competitive/src/algorithm/partisan_game.rs (line 85)

    pub fn eval(&mut self, s: &G::State) -> i64 {
        if let Some(n) = self.number.get(s).cloned() {
            n
        } else {
            let lmax = self
                .game
                .next_left(s)
                .map(|ns| self.eval(&ns))
                .fold(i64::MIN, Ord::max);
            let rmin = self
                .game
                .next_right(s)
                .map(|ns| self.eval(&ns))
                .fold(i64::MAX, Ord::min);
            let res = Self::simple_number(lmax, rmin);
            self.number.insert(s.clone(), res);
            res
        }
    }

fn simple_number(lmax: i64, rmin: i64) -> i64

Examples found in repository

crates/competitive/src/algorithm/partisan_game.rs (line 92)

    pub fn eval(&mut self, s: &G::State) -> i64 {
        if let Some(n) = self.number.get(s).cloned() {
            n
        } else {
            let lmax = self
                .game
                .next_left(s)
                .map(|ns| self.eval(&ns))
                .fold(i64::MIN, Ord::max);
            let rmin = self
                .game
                .next_right(s)
                .map(|ns| self.eval(&ns))
                .fold(i64::MAX, Ord::min);
            let res = Self::simple_number(lmax, rmin);
            self.number.insert(s.clone(), res);
            res
        }
    }

Trait Implementations

impl<G> Clone for PartisanGameAnalyzer<G>

where G: PartisanGame<State: Eq + Hash> + Clone, G::State: Clone,

fn clone(&self) -> PartisanGameAnalyzer<G>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G> Debug for PartisanGameAnalyzer<G>

where G: PartisanGame<State: Eq + Hash> + Debug, G::State: Debug,

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

Formats the value using the given formatter.