sudoku-solver-rust/src/hecht.rs

use std::collections::HashMap;

use crate::solver::Solver;
use crate::playground::Playground;
use crate::utils::Locatable;
use crate::utils::LocatableVec;

pub struct HechtSolver {
}


#[derive(Hash, Clone, Copy, Eq, PartialEq, Debug)]
struct Point {
    pub x: usize,
    pub y: usize,
    pub s: usize,
}

impl Locatable for Point {
    fn get_xy(&self) -> (usize, usize) {
        (self.x,self.y)
    }
}

#[derive(Debug)]
struct Action {
    pub p : Point,
    pub value: u16
}

#[derive(Clone)]
pub struct SolverPlayground {
    arr: [[u16; 9]; 9],
    // todos : HashSet<Point>,
    todos: LocatableVec<Point>,
    valid: bool,
    rec_level: usize,
}

impl HechtSolver {
    pub fn new() -> HechtSolver {
        return HechtSolver {};
    }
}

impl Solver for HechtSolver {
    fn solve(&self, pg: &Playground) -> Option<Playground> {
        SolverPlayground::new(&pg)
            .solve()
    }
}

impl SolverPlayground {
    
    pub fn new(pg: &Playground) -> SolverPlayground {
        let mut points : LocatableVec<Point> = LocatableVec::new();
        for x in 0..9 {
            for y in 0..9 {
                points.put(Point{x, y, s: y / 3 * 3 + x / 3});
            }
        }
        
        let mut spg = SolverPlayground { arr: [[0x1FFu16; 9]; 9], todos: points.clone(), valid: true, rec_level: 0};
        
        for p in points.iter() {
            if let Some(value) = pg.get_value(p.x, p.y) {
                spg.set_value(&p, value);
            }
        }
        
        spg
    }
    
    fn to_playground(&self) -> Option<Playground> {
        let mut pg = Playground::new();
        
        let bitmap = SolverPlayground::get_bitvalue_mapping();
        
        for x in 0..9 {
            for y in 0..9 {
                let value = self.arr[y][x];
                if value == 0 {
                    return None
                }
                pg.set_value(x, y, *bitmap.get(&value).unwrap_or(&0u8));
            }
        }
        
        Some(pg)
    }

    pub fn solve(&mut self) -> Option<Playground> {
        while self.valid && self.todos.len() > 0 {
            let actions = self.get_simple_action();
            if actions.len() == 0 {
                return self.get_complex_action();
            }
            
            for action in actions {
                self.apply(&action);
            }
        }
        
        self.to_playground()
    }

    fn set_value(&mut self, p : &Point, value : u8) {
        let bit_value = 1u16 << (value - 1);
        self.set_bit_value(p, bit_value)
    }
    
    fn set_bit_value(&mut self, p : &Point, bit_value : u16) {
        if !self.todos.remove(p) {
            // Point was not in todo-list -> no further action required
            return;
        }

        self.arr[p.y][p.x] = bit_value;
        
        let toprocess : Vec::<_> = self.todos.iter()
            // Filter positions that do not have the right coordinates
            .filter(|&pos| pos.x == p.x || pos.y == p.y || pos.s == p.s)
            // Filter positions that were known not to hold the value
            .filter(|&pos| (self.arr[pos.y][pos.x] & bit_value) != 0)
            .cloned()
            .collect();

        toprocess.iter().next();

        for pos in toprocess {
            self.remove_value(&pos, bit_value);
        }
    }
    
    fn remove_value(&mut self, p : &Point, bit_value: u16) {
        if (self.get_value(p) & bit_value) == 0 {
            return;
        }
        self.arr[p.y][p.x] &= !bit_value;
        
        if let Some(action) = SolverPlayground::create_action(p, self.arr[p.y][p.x]) {
            self.apply(&action);
        } else if self.arr[p.y][p.x] == 0 {
            self.valid = false;
        }
    }
    
    fn create_action(p : &Point, bit_value: u16) -> Option<Action> {
        if bit_value.count_ones() != 1 {
            return None;
        }
        Some(Action{p : p.clone(), value : bit_value})
    }
    
    fn apply(&mut self, action : &Action) {
        self.set_bit_value(&action.p, action.value);
    }
    
    #[inline]
    fn get_bitvalue_sequence() -> &'static[u16; 9] {
        return &[0b0_0000_0001u16, // 1
                 0b0_0000_0010u16, // 2
                 0b0_0000_0100u16, // 3
                 0b0_0000_1000u16, // 4
                 0b0_0001_0000u16, // 5
                 0b0_0010_0000u16, // 6
                 0b0_0100_0000u16, // 7
                 0b0_1000_0000u16, // 8
                 0b1_0000_0000u16]; // 9
    }
    
    #[inline]
    fn get_bitvalue_mapping() -> HashMap<u16, u8> {
        let sequence = SolverPlayground::get_bitvalue_sequence();
        let mut result : HashMap<u16, u8> = HashMap::with_capacity(sequence.len());
        
        for (index, value) in sequence.iter().enumerate() {
            result.insert(*value, (index + 1) as u8);
        }
        
        result
    }
    
    #[inline]
    fn get_value(&self, p : &Point) -> u16 {
        return self.arr[p.y][p.x];
    }

    fn get_simple_action(&self) -> Vec<Action> {
        // println!("Simple Action");
        self.todos.iter()
            .filter_map(|lhs| {
                    let own_value = self.get_value(&lhs);
                    self.todos.iter()
                        .filter(|&rhs| lhs.x == rhs.x || lhs.y == rhs.y || lhs.s == rhs.s)
                        .filter(|&rhs| lhs != rhs)
                        .map(|&rhs| {
                            let value = self.get_value(&rhs) & own_value;
                            let row_value = if lhs.x == rhs.x {value} else {0};
                            let col_value = if lhs.y == rhs.y {value} else {0};
                            let sec_value = if lhs.s == rhs.s {value} else {0};
                            
                            [row_value, col_value, sec_value]
                        } )
                        .reduce(|a,b| [a[0]|b[0], a[1]|b[1], a[2]|b[2]])
                        .iter()
                        .flatten()
                        .map(|value| value ^ own_value)
                        .filter(|value| value.count_ones() == 1)
                        .find_map(|value| SolverPlayground::create_action(lhs, value))
                } )
            .collect()
    }
    
    fn get_complex_action(&self) -> Option<Playground> {
        // println!("Complex Action");
        let result = self.todos.iter()
            .min_by_key(|x| self.get_value(x).count_ones());

        if let Some(point) = result {
            return SolverPlayground::get_bitvalue_sequence().iter()
                .filter(|&value| value & self.get_value(point) != 0)
                .find_map(|&value| {
                   let mut spg = self.clone();
                   spg.rec_level += 1;
                   spg.set_bit_value(&point, value);
                   spg.solve()
                })
        }
        None
    }
}