From c22d4f14d791fa8488127d4c3e7d723aa81a71e9 Mon Sep 17 00:00:00 2001 From: Dan Johnson Date: Thu, 11 Sep 2025 13:19:44 -0700 Subject: [PATCH 1/6] Change A* heuristic to be a proper estimate This makes it: - Actually find the path with the fewest number of moves, and - Not be so prone to getting stuck exploring space that seems "close to a solution" but is actually a dead end. --- src/main.rs | 55 +++++++++++++++++++++++++++++++++-------------------- 1 file changed, 34 insertions(+), 21 deletions(-) diff --git a/src/main.rs b/src/main.rs index d302c5e..7481c80 100644 --- a/src/main.rs +++ b/src/main.rs @@ -322,22 +322,8 @@ impl Game { hasher.finish() }; - #[derive(PartialEq)] - struct Ordf32(f32); - impl Eq for Ordf32 {} - impl PartialOrd for Ordf32 { - fn partial_cmp(&self, other: &Self) -> Option { - Some(self.cmp(other)) - } - } - impl Ord for Ordf32 { - fn cmp(&self, other: &Self) -> std::cmp::Ordering { - self.0.total_cmp(&other.0) - } - } - let mut states = Vec::new(); - let mut todo = BinaryHeap::<(Ordf32, usize, usize)>::new(); + let mut todo = BinaryHeap::<((i64, i64), i64, usize)>::new(); let mut had = HashSet::new(); let mut ctr = 0; @@ -346,7 +332,7 @@ impl Game { parent_index: 0, m: Move::new(0, 0), }); - todo.push((Ordf32(0.0), 1000000000, 0)); + todo.push(((0, 0), 1000000000, 0)); while let Some((score, depth, state_index)) = todo.pop() { ctr += 1; @@ -387,8 +373,36 @@ impl Game { working_instance.towers = state.towers.clone(); working_instance.make_move(m).unwrap(); - let num_solved = working_instance.num_solved(); - let brs = working_instance.burried_ring_score(); + let brs: i64 = { + let this = &working_instance; + let mut seen_bottom_rings = HashSet::new(); + this.towers + .iter() + .map(|i| { + let this = &i; + let mut ring_type = None; + let mut burried_score = 0; + + for ring in this.rings.iter().rev().flatten() { + if let Some(existing_ring_type) = ring_type + && existing_ring_type != *ring + { + burried_score += 1; + } + ring_type = Some(*ring); + } + if let Some(Some(ring)) = this.rings.last() { + if seen_bottom_rings.contains(ring) { + burried_score += 1; + } else { + seen_bottom_rings.insert(ring); + } + } + + burried_score + }) + .sum() + }; let new_state_hash = hash_state(&working_instance.towers); if had.contains(&new_state_hash) { @@ -402,9 +416,8 @@ impl Game { m, }); - let score = (num_solved as f32 * 10.0) + (-(brs as f32) * 100.0); - - todo.push((Ordf32(score), depth - 1, new_state_index)); + let score = (depth) - (brs); + todo.push(((score, -depth), depth - 1, new_state_index)); } } From 727a738fd4f63861a400a55dc13515e244cf8bf5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= Date: Fri, 2 Jan 2026 15:03:54 +0100 Subject: [PATCH 2/6] change problem size --- src/main.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main.rs b/src/main.rs index d302c5e..73931af 100644 --- a/src/main.rs +++ b/src/main.rs @@ -762,7 +762,7 @@ fn main() -> io::Result<()> { let mut g = GameGenerator { num_extra_towers: 2, - num_ring_types: 13, + num_ring_types: 16, } .highest_burried_score::<4>(&seed); From fc5872a5af00249dc6381648a4c3db9960d85319 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= Date: Fri, 2 Jan 2026 15:03:54 +0100 Subject: [PATCH 3/6] don't allow moving towers of the same color to empty spots --- src/main.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/main.rs b/src/main.rs index 73931af..6f7dae2 100644 --- a/src/main.rs +++ b/src/main.rs @@ -280,6 +280,13 @@ impl Game { continue; } + let rings = self.towers[from_tower].rings; + if rings[1..].iter().all(|i| i == &rings[0]) + && self.towers[to_tower].rings[0].is_none() + { + continue; + } + let m = Move::new(from_tower, to_tower); if self.try_make_move(m, true).is_ok() { res.push(m); From 82fbdec1c74699330fb3d10e7ba0e005a3def76a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= Date: Fri, 2 Jan 2026 15:03:54 +0100 Subject: [PATCH 4/6] minor symmetry breaking: dont hash solved towers --- src/main.rs | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/src/main.rs b/src/main.rs index 6f7dae2..48ac66b 100644 --- a/src/main.rs +++ b/src/main.rs @@ -319,10 +319,25 @@ impl Game { } } + fn tower_solved(tower: &Tower) -> bool { + tower + .rings + .iter() + .all(|x| x.is_some() && x == &tower.rings[0]) + } + let hash_state = |s: &[Tower]| { let mut hasher = DefaultHasher::default(); - for x in s.iter().filter(|i| i.height() != 0).enumerate() { + let num_finished_towers = s.iter().filter(|i| tower_solved(*i)).count(); + + num_finished_towers.hash(&mut hasher); + + for x in s + .iter() + .filter(|i| !tower_solved(i) && i.height() != 0) + .enumerate() + { x.hash(&mut hasher); } From 37b01f2102dd51bee7a8226d8cf8e56320f27a66 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= Date: Fri, 2 Jan 2026 16:14:01 +0100 Subject: [PATCH 5/6] sort --- src/main.rs | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-) diff --git a/src/main.rs b/src/main.rs index 48ac66b..db5c9db 100644 --- a/src/main.rs +++ b/src/main.rs @@ -326,18 +326,38 @@ impl Game { .all(|x| x.is_some() && x == &tower.rings[0]) } - let hash_state = |s: &[Tower]| { + let hash_state = |towers: &[Tower]| { let mut hasher = DefaultHasher::default(); - let num_finished_towers = s.iter().filter(|i| tower_solved(*i)).count(); + let num_finished_towers = towers.iter().filter(|i| tower_solved(*i)).count(); num_finished_towers.hash(&mut hasher); - - for x in s + let mut filtered_towers = towers .iter() .filter(|i| !tower_solved(i) && i.height() != 0) .enumerate() - { + .collect::>(); + + filtered_towers.sort_by_cached_key(|(index, tower)| { + let mut rings = [0; TOWER_HEIGHT]; + + let mut count = 0; + for (idx, ring) in tower.rings.iter().copied().enumerate() { + let Some(ring) = ring else { break }; + + if rings[idx] == 0 { + count += 1; + for (j, ring2) in tower.rings[idx..].iter().copied().enumerate() { + if ring2 == Some(ring) { + rings[j] = count; + } + } + } + } + (rings, *index) + }); + + for x in filtered_towers.into_iter().map(|(_, x)| x).enumerate() { x.hash(&mut hasher); } From 6fc85b3d828e938dadfaadbdda58dd721f42a2bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= Date: Fri, 2 Jan 2026 16:24:24 +0100 Subject: [PATCH 6/6] canonicalize colors --- src/main.rs | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/src/main.rs b/src/main.rs index db5c9db..e0df591 100644 --- a/src/main.rs +++ b/src/main.rs @@ -78,6 +78,12 @@ impl Tower { tower } + fn map(self, f: impl FnMut(Option) -> Option) -> Self { + Self { + rings: self.rings.map(f), + } + } + fn burried_score(&self) -> usize { let mut ring_type = None; let mut same_ring_type_score = 0; @@ -357,7 +363,21 @@ impl Game { (rings, *index) }); - for x in filtered_towers.into_iter().map(|(_, x)| x).enumerate() { + let mut color_assignment = [None::; 100]; + let mut num_seen = 0; + let relabelled_towers = filtered_towers.iter().map(|(_, x)| x).map(|tower| { + tower.map(|ring| { + ring.map(|ring| { + *color_assignment[ring.0.get()].get_or_insert_with(|| { + num_seen += 1; + let ring = Ring(NonZero::new(num_seen).unwrap()); + ring + }) + }) + }) + }); + + for x in relabelled_towers.into_iter().enumerate() { x.hash(&mut hasher); }