add unique paths calculation

Author: feschber

solitaire-game/src/total_progress.rs

@@ -80,7 +80,7 @@ fn update_total_progress(
                 .normalized_explored_states
                 .entry(board.normalize())
                 .or_insert(Default::default()) += 1;
-            total_progress.explored_states_by_pegs[board.count_balls() as usize - 1].insert(board);
+            total_progress.explored_states_by_pegs[board.count_pegs() as usize - 1].insert(board);
         }
     }
 }

solitaire-solver/src/board.rs

@@ -357,8 +357,8 @@ impl Board {
         self.movable_positions(dir) & self & !self.dir_shift(dir, 1) & !self.dir_shift(dir, 2)
     }
 
-    pub const fn count_balls(&self) -> u64 {
-        self.0.count_ones() as u64
+    pub const fn count_pegs(&self) -> usize {
+        self.0.count_ones() as usize
     }
 
     #[inline(always)]

solitaire-solver/src/calc_success.rs

@@ -12,7 +12,7 @@ pub fn calculate_p_random_chance_success(feasible: Vec<Board>) -> HashMap<Board,
         let feasible_with_i_pegs = feasible
             .iter()
             .copied()
-            .filter(|b| b.count_balls() == i as u64)
+            .filter(|b| b.count_pegs() == i)
             .collect::<Vec<_>>();
         for constellation in feasible_with_i_pegs {
             let legal_moves = constellation.get_legal_moves();

solitaire-solver/src/lib.rs

@@ -28,7 +28,7 @@ pub use hash::{CustomHashMap as HashMap, CustomHashSet as HashSet};
 pub use mov::Move;
 pub use solution::{Solution, SolutionMultiset};
 
-pub use unique_solutions::all_unique_solutions;
+pub use unique_solutions::{all_unique_paths, all_unique_solutions};
 
 use crate::sort::Sort;
 

solitaire-solver/src/unique_solutions.rs

@@ -1,6 +1,7 @@
 use crate::solution::SolutionMultiset;
-use crate::{Board, Move};
+use crate::{Board, Move, normalize};
 use crate::{HashSet, Solution};
+use std::array;
 use std::collections::BTreeMap;
 
 /// we define two solutions as "equal" when the
@@ -137,4 +138,31 @@ impl ZobristTable {
 type MultisetHash = u64;
 
 #[allow(unused)]
-pub fn all_unique_paths(feasible: &HashSet<Board>) {}
+pub fn all_unique_paths(feasible: impl IntoIterator<Item = Board>) -> HashMap<Board, usize> {
+    let mut number_of_combinations: HashMap<Board, usize, _> = HashMap::new();
+    let mut boards: [Vec<Board>; 33] = array::from_fn(|_| Default::default());
+    let mut feasible_set: HashSet<Board> = HashSet::default();
+    for board in feasible.into_iter() {
+        feasible_set.insert(board);
+        boards[board.count_pegs()].push(board);
+    }
+    number_of_combinations.insert(Board::solved(), 1);
+    for i in 2..=32 {
+        for board in &boards[i] {
+            let mut next = Board::possible_moves(&[*board]);
+            normalize(&mut next);
+            next.dedup();
+
+            let count = next
+                .into_iter()
+                .filter(|b| feasible_set.contains(b))
+                .map(|b| number_of_combinations[&b])
+                .sum();
+            let entry = number_of_combinations
+                .entry(*board)
+                .or_insert(Default::default());
+            *entry = count;
+        }
+    }
+    number_of_combinations
+}

src/main.rs

@@ -30,6 +30,8 @@ enum Command {
     CalculateRandomChanceSuccessRatio,
     /// calculate unique solutions
     UniqueSolutions,
+    /// calculate unique paths of solutions
+    UniquePaths,
 }
 
 fn main() {
@@ -85,6 +87,12 @@ fn main() {
                     solitaire_solver::all_unique_solutions(Board::default(), feasible.into_iter());
                 log::info!("unique solutions: {}", solutions.len());
             }
+            Command::UniquePaths => {
+                let feasible = solitaire_solver::calculate_all_solutions(None);
+                log::info!("feasible: {}", feasible.len());
+                let paths = solitaire_solver::all_unique_paths(feasible);
+                log::info!("unique paths: {}", paths.get(&Board::default()).unwrap());
+            }
         },
         None => {
             #[cfg(feature = "game")]