colormap: more compact representation

Author: danieledapo

src/colormap.rs

@@ -1,10 +1,14 @@
 use crate::map::RegionId;
 use crate::Map;
 
-#[derive(Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ColorMap {
- // possible colors by regionid. A color is represented as a 4 bit bitmask.
+ // possible colors by regionid. A color is represented as a 4 bit bitmask and each element
+ // contains the possible colors for 2 regions.
  possible_colors: Vec<u8>,
+
+ // number of regions of this colormap.
+ regions: usize,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -16,6 +20,12 @@ pub enum Color {
  C4 = 1 << 3,
 }
 
+enum SolutionState {
+ CannotSolve,
+ Solved,
+ Unknown,
+}
+
 impl ColorMap {
  pub fn color(m: &Map) -> Option<ColorMap> {
  Self::all_possible_colorings(m).next()
@@ -26,7 +36,8 @@ impl ColorMap {
  }
 
  pub fn color_of_region(&self, rid: RegionId) -> Color {
- let c = self.possible_colors[rid];
+ let c = self.at(rid);
+
  if c == Color::C1 as u8 {
  return Color::C1;
  }
@@ -50,29 +61,94 @@ impl ColorMap {
  unreachable!()
  }
  }
+
+ fn at(&self, rid: RegionId) -> u8 {
+ assert!(rid < self.regions);
+
+ let pcs = self.possible_colors[rid / 2];
+ if rid & 1 != 0 {
+ pcs >> 4
+ } else {
+ pcs & 0xf
+ }
+ }
+
+ fn set(&mut self, rid: RegionId, v: u8) {
+ assert!(rid < self.regions);
+
+ let old = self.possible_colors[rid / 2];
+ let pcs = if rid & 1 != 0 {
+ (v << 4) | (old & 0xf)
+ } else {
+ (old & 0xf0) | (v & 0xf)
+ };
+
+ self.possible_colors[rid / 2] = pcs;
+ }
+
+ fn remove_conflicts(&mut self, map: &Map) -> SolutionState {
+ loop {
+ // first find regions with a single possible colors and remove that color from its
+ // neighbors until no regions change its respective colors. If any of the regions cannot be
+ // colored then this map cannot be colored. On the other hand, if all the regions have a
+ // single possible color then that's the solution.
+ let mut stalled = true;
+ let mut solved = true;
+
+ for rid in 0..self.regions {
+ let c = self.at(rid);
+ if c == 0 {
+ return SolutionState::CannotSolve;
+ }
+
+ if c.count_ones() != 1 {
+ solved = false;
+ continue;
+ }
+
+ for &neigh in &map.regions[rid].neighbors {
+ let old = self.at(neigh);
+ let new = old & !c;
+
+ self.set(neigh, new);
+ if old != new {
+ stalled = false;
+ solved = false;
+ }
+ }
+ }
+
+ if stalled {
+ break if solved {
+ SolutionState::Solved
+ } else {
+ SolutionState::Unknown
+ };
+ }
+ }
+ }
 }
 
 #[derive(Debug)]
 struct SolutionIter<'m> {
- stack: Vec<Vec<u8>>,
+ stack: Vec<ColorMap>,
  map: &'m Map,
 }
 
 impl<'m> SolutionIter<'m> {
  fn new(map: &'m Map) -> Self {
+ let cm = vec![0xff; map.regions.len() / 2 + (map.regions.len() & 1)];
+
  SolutionIter {
  map,
- stack: vec![vec![0xf; map.regions.len()]],
+ stack: vec![ColorMap {
+ possible_colors: cm,
+ regions: map.regions.len(),
+ }],
  }
  }
 }
 
-enum SolutionState {
- CannotSolve,
- Solved,
- Unknown,
-}
-
 impl Iterator for SolutionIter<'_> {
  type Item = ColorMap;
 
@@ -81,19 +157,17 @@ impl Iterator for SolutionIter<'_> {
  let possible_colors_len =
  |pc: u8| ((pc >> 3) & 1) + ((pc >> 2) & 1) + ((pc >> 1) & 1) + (pc & 1);
 
- while let Some(mut possible_colors) = self.stack.pop() {
- let state = remove_conflicts(&mut possible_colors, &self.map);
+ while let Some(mut color_map) = self.stack.pop() {
+ let state = color_map.remove_conflicts(self.map);
 
  match state {
- SolutionState::Solved => return Some(ColorMap { possible_colors }),
+ SolutionState::Solved => return Some(color_map),
  SolutionState::CannotSolve => continue,
  SolutionState::Unknown => {
  // pick the region with the smallest amount of possible colors to choose from so that we
  // have to explore less space
- let (candidate_i, _) = possible_colors
- .iter()
- .enumerate()
- .map(|(i, &pc)| (i, possible_colors_len(pc)))
+ let (candidate_rid, _) = (0..color_map.regions)
+ .map(|rid| (rid, possible_colors_len(color_map.at(rid))))
  .filter(|(_, pcl)| {
  // regions that have a single possible color are fixed and cannot be
  // changed, aka they're not candidates
@@ -102,16 +176,16 @@ impl Iterator for SolutionIter<'_> {
  .min_by_key(|(_, pcl)| *pcl)?;
 
  // try all the possible colors for the candidate and recursively find a solution
- let pcs = possible_colors[candidate_i];
+ let pcs = color_map.at(candidate_rid);
  self.stack.extend(
  [Color::C1, Color::C2, Color::C3, Color::C4]
  .iter()
  .rev()
  .filter(|&&c| has_color(pcs, c))
  .map(|&c| {
- let mut new_possible_colors = possible_colors.clone();
- new_possible_colors[candidate_i] = c as u8;
- new_possible_colors
+ let mut new_color_map = color_map.clone();
+ new_color_map.set(candidate_rid, c as u8);
+ new_color_map
  }),
  );
  }
@@ -121,44 +195,3 @@ impl Iterator for SolutionIter<'_> {
  None
  }
 }
-
-fn remove_conflicts(possible_colors: &mut [u8], map: &Map) -> SolutionState {
- loop {
- // first find regions with a single possible colors and remove that color from its
- // neighbors until no regions change its respective colors. If any of the regions cannot be
- // colored then this map cannot be colored. On the other hand, if all the regions have a
- // single possible color then that's the solution.
- let mut stalled = true;
- let mut solved = true;
-
- for rid in 0..possible_colors.len() {
- let c = possible_colors[rid];
- if c == 0 {
- return SolutionState::CannotSolve;
- }
-
- if c.count_ones() != 1 {
- solved = false;
- continue;
- }
-
- for &neigh in &map.regions[rid].neighbors {
- let old = possible_colors[neigh];
- possible_colors[neigh] &= !c;
-
- if old != possible_colors[neigh] {
- stalled = false;
- solved = false;
- }
- }
- }
-
- if stalled {
- break if solved {
- SolutionState::Solved
- } else {
- SolutionState::Unknown
- };
- }
- }
-}