2025 08.2

Author: Lexicality

src/aoc/y2025/day08.rs

@@ -11,7 +11,7 @@ use std::{cmp::Ordering, collections::HashSet};
 
 use itertools::Itertools;
 
-use crate::{AoCResult, Coord3D};
+use crate::Coord3D;
 
 // now you're just being intentionally anonying ¬_¬
 fn dist(a: Coord3D, b: Coord3D) -> i64 {
@@ -20,18 +20,18 @@ fn dist(a: Coord3D, b: Coord3D) -> i64 {
         + (a.z as i64 - b.z as i64).pow(2)
 }
 
-fn get_distances(data: crate::DataIn) -> AoCResult<Vec<(i64, (Coord3D, Coord3D))>> {
-    let coords: Vec<Coord3D> = data.map(|line| line.parse()).try_collect()?;
-    Ok(coords
+fn get_distances(coords: Vec<Coord3D>) -> Vec<(i64, (Coord3D, Coord3D))> {
+    coords
         .into_iter()
         .array_combinations()
         .map(|[a, b]| (dist(a, b), (a, b)))
         .sorted_unstable()
-        .collect())
+        .collect()
 }
 
 pub fn part_1(data: crate::DataIn, num_connections: usize) -> crate::AoCResult<String> {
-    let distances = get_distances(data)?;
+    let coords: Vec<Coord3D> = data.map(|line| line.parse()).try_collect()?;
+    let distances = get_distances(coords);
 
     log::trace!("distances! {distances:?}");
 
@@ -91,12 +91,87 @@ pub fn part_1(data: crate::DataIn, num_connections: usize) -> crate::AoCResult<S
     Ok(ret.to_string())
 }
 
+pub fn part_2(data: crate::DataIn) -> crate::AoCResult<String> {
+    let coords: Vec<Coord3D> = data.map(|line| line.parse()).try_collect()?;
+    let mut circuits: Vec<HashSet<Coord3D>> = coords
+        .iter()
+        .map(|coord| [*coord].into_iter().collect())
+        .collect();
+    let distances = get_distances(coords);
+
+    log::trace!("distances! {distances:?}");
+
+    let mut ret = 0;
+
+    for (distance, (a, b)) in distances.iter() {
+        log::debug!("Looking at pair {a}, {b} with distance {distance}!");
+
+        let a_circuit = circuits
+            .iter()
+            .find_position(|col| col.contains(a))
+            .map(|(pos, _)| pos);
+        let b_circuit = circuits
+            .iter()
+            .find_position(|col| col.contains(b))
+            .map(|(pos, _)| pos);
+        match (a_circuit, b_circuit) {
+            (None, None) => {
+                log::debug!("New circuit time");
+                circuits.push([a, b].into_iter().copied().collect())
+            }
+            (Some(pos), None) => {
+                log::debug!("a is already in a circuit, adding b");
+                circuits[pos].insert(*b);
+            }
+            (None, Some(pos)) => {
+                log::debug!("b is already in a circuit, adding a");
+                circuits[pos].insert(*a);
+            }
+            (Some(pos_a), Some(pos_b)) => {
+                let (winner, loser) = match pos_a.cmp(&pos_b) {
+                    Ordering::Less => (pos_a, pos_b),
+                    Ordering::Equal => {
+                        log::debug!("They're already in the same circuit!");
+                        // both in same circuit
+                        continue;
+                    }
+                    Ordering::Greater => (pos_b, pos_a),
+                };
+                log::debug!("Both in separate circuits, merging!");
+                let loser = circuits.swap_remove(loser);
+                circuits[winner].extend(loser);
+                if circuits.len() == 1 {
+                    log::debug!("Fully merginated!");
+                    // we're fully merged
+                    ret = a.x as i64 * b.x as i64;
+                    break;
+                }
+            }
+        }
+    }
+
+    // log::debug!("There are {} circuits!", circuits.len());
+    //
+    // let ret: usize = circuits
+    //     .into_iter()
+    //     .map(|circuit| circuit.len())
+    //     .sorted_unstable()
+    //     .rev()
+    //     .take(3)
+    //     .inspect(|c| log::debug!("Final circuit size {c}"))
+    //     .product();
+    Ok(ret.to_string())
+}
+
 inventory::submit!(crate::AoCDay {
     year: "2025",
     day: "8",
     part_1: crate::AoCPart {
         main: |data| part_1(data, 1000),
         example: |data| part_1(data, 10)
     },
-    part_2: None
+    part_2: Some(crate::AoCPart {
+        main: part_2,
+        example: part_2
+    })
 });