Much faster iterative approach

Author: maneatingape

README.md

@@ -82,7 +82,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 8 | [Resonant Collinearity](https://adventofcode.com/2024/day/8) | [Source](src/year2024/day08.rs) | 8 |
 | 9 | [Disk Fragmenter](https://adventofcode.com/2024/day/9) | [Source](src/year2024/day09.rs) | 106 |
 | 10 | [Hoof It](https://adventofcode.com/2024/day/10) | [Source](src/year2024/day10.rs) | 38 |
-| 11 | [Plutonian Pebbles](https://adventofcode.com/2024/day/11) | [Source](src/year2024/day11.rs) | 2378 |
+| 11 | [Plutonian Pebbles](https://adventofcode.com/2024/day/11) | [Source](src/year2024/day11.rs) | 248 |
 
 ## 2023
 

src/year2024/day11.rs

@@ -1,10 +1,10 @@
 //! # Plutonian Pebbles
 //!
-//! Each stone is independent and does not affect its neighbours. This means that we can
-//! recursively split each stone, skipping trillions of calculations by memoizing the count for
-//! each `(stone, blinks)` tuple.
+//! The transformation rules have any interesting property that the total number of
+//! distinct stone numbers is not very large, about 2000 for part one and 4000 for part two.
 //!
-//! Interestingly the number of distinct stones is not too large, about 5000 for part two.
+//! This means that we can store the count of each distinct stone in a small contigous array
+//! that is much faster to process than a recursive memoization approach.
 use crate::util::hash::*;
 use crate::util::parse::*;
 
@@ -13,41 +13,77 @@ pub fn parse(input: &str) -> Vec<u64> {
 }
 
 pub fn part1(input: &[u64]) -> u64 {
-    let cache = &mut FastMap::with_capacity(5_000);
-    input.iter().map(|&stone| count(cache, stone, 25)).sum()
+    count(input, 25)
 }
 
 pub fn part2(input: &[u64]) -> u64 {
-    let cache = &mut FastMap::with_capacity(150_000);
-    input.iter().map(|&stone| count(cache, stone, 75)).sum()
+    count(input, 75)
 }
 
-fn count(cache: &mut FastMap<(u64, u64), u64>, stone: u64, blinks: u64) -> u64 {
-    if blinks == 1 {
-        if stone == 0 {
-            return 1;
+fn count(input: &[u64], blinks: usize) -> u64 {
+    // Allocate enough room to prevent reallocations.
+    let mut stones = Vec::with_capacity(5000);
+    // Maps number on stone to a much smaller contigous range of indices.
+    let mut indices = FastMap::with_capacity(5000);
+    // Numbers of any new stones generated during the previous blink.
+    let mut todo = Vec::new();
+    // Amount of each stone of a particular number.
+    let mut current = Vec::new();
+
+    // Initialize stones from input.
+    for &number in input {
+        if let Some(&index) = indices.get(&number) {
+            current[index] += 1;
+        } else {
+            indices.insert(number, indices.len());
+            todo.push(number);
+            current.push(1);
         }
-        let digits = stone.ilog10() + 1;
-        return if digits % 2 == 0 { 2 } else { 1 };
     }
 
-    let key = (stone, blinks);
-    if let Some(&value) = cache.get(&key) {
-        return value;
-    }
+    for _ in 0..blinks {
+        // If a stone number has already been seen then return its index,
+        // otherwise queue it for processing during the next blink.
+        let numbers = todo;
+        todo = Vec::with_capacity(200);
 
-    let next = if stone == 0 {
-        count(cache, 1, blinks - 1)
-    } else {
-        let digits = stone.ilog10() + 1;
-        if digits % 2 == 0 {
-            let power = 10_u64.pow(digits / 2);
-            count(cache, stone / power, blinks - 1) + count(cache, stone % power, blinks - 1)
-        } else {
-            count(cache, stone * 2024, blinks - 1)
+        let mut index_of = |number| {
+            let size = indices.len();
+            *indices.entry(number).or_insert_with(|| {
+                todo.push(number);
+                size
+            })
+        };
+
+        // Apply the transformation logic to stones added in the previous blink.
+        for number in numbers {
+            let (first, second) = if number == 0 {
+                (index_of(1), usize::MAX)
+            } else {
+                let digits = number.ilog10() + 1;
+                if digits % 2 == 0 {
+                    let power = 10_u64.pow(digits / 2);
+                    (index_of(number / power), index_of(number % power))
+                } else {
+                    (index_of(number * 2024), usize::MAX)
+                }
+            };
+
+            stones.push((first, second));
         }
-    };
 
-    cache.insert(key, next);
-    next
+        // Add amount of each stone to either 1 or 2 stones in the next blink.
+        let mut next = vec![0; indices.len()];
+
+        for (&(first, second), amount) in stones.iter().zip(current) {
+            next[first] += amount;
+            if second != usize::MAX {
+                next[second] += amount;
+            }
+        }
+
+        current = next;
+    }
+
+    current.iter().sum()
 }