From 727a738fd4f63861a400a55dc13515e244cf8bf5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Fri, 2 Jan 2026 15:03:54 +0100
Subject: [PATCH 1/4] 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?= <jana@donsz.nl>
Date: Fri, 2 Jan 2026 15:03:54 +0100
Subject: [PATCH 2/4] 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<const TOWER_HEIGHT: usize> Game<TOWER_HEIGHT> {
                     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?= <jana@donsz.nl>
Date: Fri, 2 Jan 2026 15:03:54 +0100
Subject: [PATCH 3/4] 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<const TOWER_HEIGHT: usize> Game<TOWER_HEIGHT> {
             }
         }
 
+        fn tower_solved<const TOWER_HEIGHT: usize>(tower: &Tower<TOWER_HEIGHT>) -> bool {
+            tower
+                .rings
+                .iter()
+                .all(|x| x.is_some() && x == &tower.rings[0])
+        }
+
         let hash_state = |s: &[Tower<TOWER_HEIGHT>]| {
             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?= <jana@donsz.nl>
Date: Fri, 2 Jan 2026 16:14:01 +0100
Subject: [PATCH 4/4] 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<const TOWER_HEIGHT: usize> Game<TOWER_HEIGHT> {
                 .all(|x| x.is_some() && x == &tower.rings[0])
         }
 
-        let hash_state = |s: &[Tower<TOWER_HEIGHT>]| {
+        let hash_state = |towers: &[Tower<TOWER_HEIGHT>]| {
             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::<Vec<_>>();
+
+            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);
             }