Faster multithreaded approach that buckets the edges by distance

Author: maneatingape

README.md

@@ -84,7 +84,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 5 | [Cafeteria](https://adventofcode.com/2025/day/5) | [Source](src/year2025/day05.rs) | 20 |
 | 6 | [Trash Compactor](https://adventofcode.com/2025/day/6) | [Source](src/year2025/day06.rs) | 20 |
 | 7 | [Laboratories](https://adventofcode.com/2025/day/7) | [Source](src/year2025/day07.rs) | 5 |
-| 8 | [Playground](https://adventofcode.com/2025/day/8) | [Source](src/year2025/day08.rs) | 12000 |
+| 8 | [Playground](https://adventofcode.com/2025/day/8) | [Source](src/year2025/day08.rs) | 527 |
 
 ## 2024
 

src/year2025/day08.rs

@@ -1,55 +1,57 @@
 //! # Playground
 use crate::util::iter::*;
 use crate::util::parse::*;
+use crate::util::thread::*;
 
-type Box = [u64; 3];
-type Pair = (usize, usize, u64);
-type Input = (Vec<Box>, Vec<Pair>);
+type Box = [usize; 3];
+type Pair = (u16, u16, usize);
+type Input = (Vec<Box>, Vec<Vec<Vec<Pair>>>);
 
 struct Node {
     parent: usize,
     size: usize,
 }
 
+const BUCKETS: usize = 5;
+const SIZE: usize = 10_000 * 10_000;
+
 pub fn parse(input: &str) -> Input {
-    let boxes: Vec<_> = input.iter_unsigned::<u64>().chunk::<3>().collect();
-    let mut pairs = Vec::with_capacity(boxes.len() * (boxes.len() - 1));
+    let boxes: Vec<_> = input.iter_unsigned::<usize>().chunk::<3>().collect();
+    let items: Vec<_> = (0..boxes.len()).collect();
+    let mut buckets = vec![vec![]; BUCKETS];
 
-    for (i, &v1) in boxes.iter().enumerate() {
-        for (j, &v2) in boxes.iter().enumerate().skip(i + 1) {
-            let dx = v1[0].abs_diff(v2[0]);
-            let dy = v1[1].abs_diff(v2[1]);
-            let dz = v1[2].abs_diff(v2[2]);
-            let distance = dx * dx + dy * dy + dz * dz;
-            pairs.push((i, j, distance));
+    for result in spawn_parallel_iterator(&items, |iter| worker(&boxes, iter)) {
+        for (bucket, pairs) in buckets.iter_mut().zip(result) {
+            bucket.push(pairs);
         }
     }
 
-    pairs.sort_unstable_by_key(|&(.., distance)| distance);
-    (boxes, pairs)
+    (boxes, buckets)
 }
 
 pub fn part1(input: &Input) -> usize {
     part1_testable(input, 1000)
 }
 
 pub fn part1_testable(input: &Input, limit: usize) -> usize {
-    let (boxes, pairs) = input;
+    let (boxes, buckets) = input;
     let mut nodes: Vec<_> = (0..boxes.len()).map(|i| Node { parent: i, size: 1 }).collect();
 
-    for &(i, j, ..) in pairs.iter().take(limit) {
-        union(&mut nodes, i, j);
+    for (i, j, ..) in flatten(buckets).take(limit) {
+        union(&mut nodes, i as usize, j as usize);
     }
 
     nodes.sort_unstable_by_key(|node| node.size);
     nodes.iter().rev().take(3).map(|node| node.size).product()
 }
 
-pub fn part2(input: &Input) -> u64 {
-    let (boxes, pairs) = input;
+pub fn part2(input: &Input) -> usize {
+    let (boxes, buckets) = input;
     let mut nodes: Vec<_> = (0..boxes.len()).map(|i| Node { parent: i, size: 1 }).collect();
 
-    for &(i, j, ..) in pairs {
+    for (i, j, ..) in flatten(buckets) {
+        let (i, j) = (i as usize, j as usize);
+
         if union(&mut nodes, i, j) == boxes.len() {
             return boxes[i][0] * boxes[j][0];
         }
@@ -58,6 +60,34 @@ pub fn part2(input: &Input) -> u64 {
     unreachable!()
 }
 
+fn worker(boxes: &[Box], iter: ParIter<'_, usize>) -> Vec<Vec<Pair>> {
+    let mut buckets = vec![vec![]; BUCKETS];
+
+    for &i in iter {
+        let v1 = boxes[i];
+
+        for (j, &v2) in boxes.iter().enumerate().skip(i + 1) {
+            let dx = v1[0].abs_diff(v2[0]);
+            let dy = v1[1].abs_diff(v2[1]);
+            let dz = v1[2].abs_diff(v2[2]);
+            let distance = dx * dx + dy * dy + dz * dz;
+
+            let index = (distance / SIZE).min(BUCKETS - 1);
+            buckets[index].push((i as u16, j as u16, distance));
+        }
+    }
+
+    buckets
+}
+
+fn flatten(buckets: &[Vec<Vec<Pair>>]) -> impl Iterator<Item = Pair> {
+    buckets.iter().flat_map(|pairs| {
+        let mut merged = pairs.concat();
+        merged.sort_unstable_by_key(|&(.., distance)| distance);
+        merged
+    })
+}
+
 fn find(set: &mut [Node], mut x: usize) -> usize {
     while set[x].parent != x {
         let parent = set[x].parent;