95 lines
3.6 KiB
Rust
95 lines
3.6 KiB
Rust
---cargo
|
|
[dependencies]
|
|
slotmap = "1"
|
|
---
|
|
|
|
use slotmap::SlotMap;
|
|
use std::collections::HashMap;
|
|
|
|
static CONTENT: &'static str = include_str!("./inputs/08_1.txt");
|
|
|
|
fn main() {
|
|
let boxes: Vec<(usize, usize, usize)> = CONTENT.lines().map(|l| l.trim()).filter(|l| !l.is_empty()).map(|l| {
|
|
let (first, rest) = l.split_once(',').unwrap();
|
|
let (second, third) = rest.split_once(',').unwrap();
|
|
|
|
let first = first.parse::<usize>().unwrap();
|
|
let second = second.parse::<usize>().unwrap();
|
|
let third = third.parse::<usize>().unwrap();
|
|
|
|
(first, second, third)
|
|
}).collect();
|
|
|
|
let mut circuits = SlotMap::<_, Vec<(usize, usize, usize)>>::new();
|
|
let mut box_circuits = HashMap::<(usize, usize, usize), slotmap::DefaultKey>::new();
|
|
|
|
println!("Boxes\n{:?}", boxes);
|
|
|
|
let mut distances: Vec<_> = boxes.iter()
|
|
.flat_map(|s| core::iter::repeat(s).zip(boxes.iter()))
|
|
.filter(|(s, t)| s != t)
|
|
.filter(|(s, t)| ((s.0.pow(2) + s.1.pow(2) + s.2.pow(2)) as f64).sqrt() < ((t.0.pow(2) + t.1.pow(2) + t.2.pow(2)) as f64).sqrt())
|
|
.map(|(s, t)| (s, t, ((s.0.abs_diff(t.0).pow(2) + s.1.abs_diff(t.1).pow(2) + s.2.abs_diff(t.2).pow(2)) as f64).sqrt()))
|
|
.collect();
|
|
distances.sort_by(|(_, _, d1), (_, _, d2)| d2.partial_cmp(d1).unwrap());
|
|
|
|
// println!("Distances\n{:#?}", distances);
|
|
|
|
let mut last_connection = None;
|
|
while box_circuits.len() < boxes.len() || circuits.len() > 1 {
|
|
let (first, second, distance) = distances.pop().unwrap();
|
|
println!("Connecting:\n\t{:?} <=> {:?}", first, second);
|
|
|
|
let first_circuit = box_circuits.get(first);
|
|
let second_circuit = box_circuits.get(second);
|
|
println!("\tFirst Circuit: {:?}", first_circuit);
|
|
println!("\tSecond Circuit: {:?}", second_circuit);
|
|
|
|
match (first_circuit.copied(), second_circuit.copied()) {
|
|
(Some(fc), Some(sc)) if fc == sc => {}
|
|
(Some(fc), Some(sc)) => {
|
|
let second_boxes = circuits.remove(sc).unwrap();
|
|
let first_boxes = circuits.get_mut(fc).unwrap();
|
|
for b in second_boxes {
|
|
first_boxes.push(b);
|
|
box_circuits.insert(b, fc);
|
|
}
|
|
|
|
last_connection = Some((first, second));
|
|
},
|
|
(Some(fc), None) => {
|
|
circuits.get_mut(fc).unwrap().push(*second);
|
|
box_circuits.insert(*second, fc);
|
|
|
|
last_connection = Some((first, second));
|
|
},
|
|
(None, Some(sc)) => {
|
|
circuits.get_mut(sc).unwrap().push(*first);
|
|
box_circuits.insert(*first, sc);
|
|
|
|
last_connection = Some((first, second));
|
|
},
|
|
(None, None) => {
|
|
let circuit = circuits.insert(vec![*first, *second]);
|
|
box_circuits.insert(*first, circuit);
|
|
box_circuits.insert(*second, circuit);
|
|
|
|
// println!("\tCreated Circuit: {:?}", circuit);
|
|
last_connection = Some((first, second));
|
|
}
|
|
};
|
|
}
|
|
|
|
let last_connection = last_connection.unwrap();
|
|
println!("Last Connection: {:?}", last_connection);
|
|
println!("Last Connection Distance: {:?}", last_connection.0.0 * last_connection.1.0);
|
|
|
|
let mut circuit_list: Vec<_> = circuits.iter().map(|(k, v)| (k, v.len())).collect();
|
|
circuit_list.sort_by_key(|(_, v)| core::cmp::Reverse(*v));
|
|
|
|
println!("Circuits: {:?}", circuit_list);
|
|
|
|
let result = circuit_list.iter().take(3).map(|(_, v)| *v).product::<usize>();
|
|
println!("Result: {:?}", result);
|
|
}
|