Struct graph_solver::MultiBackTrackSolver

pub struct MultiBackTrackSolver<T> where
    T: Puzzle,  {
    pub states: Vec<T>,
    pub prevs: Vec<Vec<(<T as Puzzle>::Pos, <T as Puzzle>::Val, bool)>>,
    pub choice: Vec<Vec<(<T as Puzzle>::Pos, Vec<<T as Puzzle>::Val>)>>,
    pub settings: SolveSettings,
}

Solves puzzle using multiple strategies at the same time. Each strategy is evaluated one step by turn until a solution is found.

Fields

states: Vec<T>

Stores the states.

prevs: Vec<Vec<(<T as Puzzle>::Pos, <T as Puzzle>::Val, bool)>>

Stores previous values before making choices. The flags is true when made a simple choice.

choice: Vec<Vec<(<T as Puzzle>::Pos, Vec<<T as Puzzle>::Val>)>>

Stores the choices for the states.

settings: SolveSettings

Search for simple solutions.

Implementations

impl<T> MultiBackTrackSolver<T> where
    T: Puzzle, 

pub fn new(settings: SolveSettings) -> MultiBackTrackSolver<T>

Creates a new solver.

pub fn solve(
    self,
    puzzle: T,
    strategies: &[(fn(&T) -> Option<<T as Puzzle>::Pos>, fn(&T, <T as Puzzle>::Pos) -> Vec<<T as Puzzle>::Val>)]
) -> Option<Solution<T>>

Solves puzzle, using a closure to look for best position to set a value next, and a closure for picking options in preferred order.

The second closure returns possible values at a given position. The last move in the list has highest priority, because the solver pops the values in turn.

If you have problems compiling, annotate type (fn(&_) -> _, fn(&_, _) -> _) to the list of strategies, e.g. Vec<(fn(&_) -> _, fn(&_, _) -> _)> or &[(fn(&_) -> _, fn(&_, _) -> _)].