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 1/5] 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 2/5] 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 3/5] 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 4/5] 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 5/5] 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); }