Struct BackTrackSolver

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

Solvees puzzles using back tracking.

Fields

original: T

Stores the original state.

state: T

Stores the state.

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

Stores the previous values of a position before making a choice. If the flag is true, the value was inserted due to a simple choice.

choice: 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> BackTrackSolver<T>

where T: Puzzle,

pub fn new(puzzle: T, settings: SolveSettings) -> BackTrackSolver<T>

Creates a new solver.

pub fn solve<F, G>(self, f: F, g: G) -> Option<Solution<T>>

where F: FnMut(&T) -> Option<<T as Puzzle>::Pos>, G: FnMut(&T, <T as Puzzle>::Pos) -> Vec<<T as Puzzle>::Val>,

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.