ktims/aoc2025
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

day12: cleanup and speedup

Browse Source
This commit is contained in:
Keenan Tims
2025-12-12 03:10:27 -08:00
parent 004591374c
commit fd6b0c846b
1 changed files with 100 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
src/day12.rs
View File

@@ -1,101 +1,64 @@
use std::iter::repeat_n;
use std::{collections::BinaryHeap, f64::consts, fmt::Display};
use aoc_runner_derive::{aoc, aoc_generator};
use grid::{Coord2d, Grid, MirrorAxis};
use itertools::{Format, Itertools};
use itertools::Itertools;
use std::collections::HashSet;
use std::fmt::Display;
use std::iter::repeat_n;
type CellType = bool;
#[derive(Debug, Clone)]
struct PresentShape {
idx: u8,
shape: Grid<u8>,
variants: Vec<Grid<u8>>,
variants: Vec<Grid<CellType>>,
}
impl From<&str> for PresentShape {
fn from(value: &str) -> Self {
let (idx, rest) = value.split_once(":\n").unwrap();
let (_idx, rest) = value.split_once(":\n").unwrap();
let shape: Grid<u8> = rest.parse().unwrap();
let shape_raw: Grid<u8> = rest.parse().unwrap();
let mut shape: Grid<CellType> = shape_raw.same_shape(false);
for pos in shape_raw.find_all(&b'#') {
shape.set(&pos, true);
}
Self {
idx: idx.parse().unwrap(),
variants: (0..4)
.map(|rot| shape.rotated(rot))
.chain([MirrorAxis::X, MirrorAxis::Y].map(|axis| shape.mirrored(axis)))
.unique()
.collect(),
shape,
}
}
}
impl Display for PresentShape {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_fmt(format_args!("{}:\n", self.idx))?;
f.write_fmt(format_args!("{}", self.shape))
f.write_fmt(format_args!("{}", self.variants[0]))
}
}
impl PresentShape {
fn make(&self) -> Present {
Present {
shape: self.clone(),
location: None,
variant: 0,
}
}
fn popcount(&self) -> u64 {
self.shape.data.iter().filter(|c| **c != b'.').count() as u64
self.variants[0].count(&true) as u64
}
}
#[derive(Debug, Clone)]
struct Present {
shape: PresentShape,
location: Option<Coord2d>,
variant: usize,
shape: usize,
}
#[derive(Debug, Clone)]
struct ChristmasTree {
area: Grid<u8>,
area: Grid<CellType>,
presents: Vec<Present>,
}
impl ChristmasTree {}
impl Display for ChristmasTree {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_fmt(format_args!("{}", self.area))?;
for (i, p) in self.presents.iter().enumerate() {
f.write_fmt(format_args!(" {i}: @{:?} rot {}\n", p.location, p.variant))?;
f.write_fmt(format_args!("{}", p.shape.variants[p.variant]))?;
}
std::fmt::Result::Ok(())
}
}
#[derive(Debug, Clone)]
struct PresentsProblem {
shapes: Vec<PresentShape>,
trees: Vec<ChristmasTree>,
}
impl PresentsProblem {
fn present(&self, idx: usize) -> Present {
Present {
shape: self.shapes[idx].clone(),
location: None,
variant: 0,
}
}
fn add_tree(&mut self, w: usize, h: usize, presents: Vec<Present>) {
self.trees.push(ChristmasTree {
area: Grid::with_shape(w, h, b'.'),
presents,
})
}
shapes: Vec<PresentShape>,
}
#[aoc_generator(day12)]
@@ -116,52 +79,63 @@ fn parse(input: &str) -> PresentsProblem {
let presents = present_counts
.iter()
.enumerate()
.flat_map(|(i, count)| repeat_n(shapes[i].make(), *count))
.flat_map(|(i, count)| repeat_n(Present { shape: i }, *count))
.collect();
trees.push(ChristmasTree {
area: Grid::with_shape(w.parse().unwrap(), h.parse().unwrap(), b'.'),
area: Grid::with_shape(w.parse().unwrap(), h.parse().unwrap(), false),
presents,
});
}
PresentsProblem { shapes, trees }
PresentsProblem { trees, shapes }
}
// place b on a and test if any # overlap any non-.
fn overlaps(a: &Grid<u8>, b: &Grid<u8>, p: &Coord2d) -> bool {
b.find_all(&b'#')
.any(|c| a.get(&(c + p)).is_some_and(|c| *c != b'.'))
}
// fn overlaps(a: &Grid<CellType>, b: &Grid<CellType>, p: &Coord2d) -> bool {
// b.find_all(&true)
// .any(|c| a.get(&(c + p)).is_some_and(|c| *c))
// }
fn place_shape(
impl PresentsProblem {
fn place_shape(
&self,
mut t: ChristmasTree,
idx: usize,
pos: Coord2d,
variant: usize,
) -> Option<ChristmasTree> {
let variant = &t.presents[idx].shape.variants[variant];
) -> Option<ChristmasTree> {
let variant = &self.shapes[t.presents[idx].shape].variants[variant];
if !overlaps(&t.area, variant, &pos) {
for xy in variant.find_all(&b'#') {
t.area.set(&(pos + &(xy)), b'0' + idx as u8).unwrap();
for xy in variant.find_all(&true) {
if let Some(was) = t.area.set(&(pos + &(xy)), true)
&& was
{
// overlapped
return None;
}
}
Some(t)
} else {
None
}
}
fn place_next(mut t: ChristmasTree, cur: usize) -> Option<ChristmasTree> {
fn place_next(
&self,
t: ChristmasTree,
cur: usize,
cache: &mut HashSet<(usize, Grid<CellType>)>, // impossible shapes
) -> Option<ChristmasTree> {
if cur == t.presents.len() {
// done
return Some(t);
}
let variants = &t.presents[cur].shape.variants;
'variant: for (i, _v) in variants.iter().enumerate() {
//make sure the longest 'bar' can fit
if cache.contains(&(cur, t.area.clone())) {
// doomed
return None;
}
let variants = &self.shapes[t.presents[cur].shape].variants;
for (i, _v) in variants.iter().enumerate() {
for y in 0..&t.area.height() - 2 {
for x in 0..&t.area.width() - 2 {
if let Some(new_t) = place_shape(
if let Some(new_t) = self.place_shape(
t.clone(),
cur,
Coord2d {
@@ -170,34 +144,48 @@ fn place_next(mut t: ChristmasTree, cur: usize) -> Option<ChristmasTree> {
},
i,
) {
if let Some(solution) = place_next(new_t, cur + 1) {
if let Some(solution) = self.place_next(new_t, cur + 1, cache) {
return Some(solution);
} else {
cache.insert((cur, t.area.clone()));
}
}
}
}
}
None
}
}
#[aoc(day12, part1)]
fn part1(input: &PresentsProblem) -> u64 {
let input = input.clone();
let mut count = 0;
// for t in input.trees[0..2].iter() {
// println!("trying:\n{t}");
// if let Some(r) = place_next(t.clone(), 0) {
// count += 1;
// println!("ok!\n{r}");
// } else {
// println!("failed :(");
// }
// }
for t in input.trees.iter() {
let area = (t.area.width() * t.area.height()) as u64;
let occupied_area = t.presents.iter().map(|p| p.shape.popcount()).sum::<u64>();
if occupied_area <= area {
count += 1
let (occupied_area, present_count) = t
.presents
.iter()
.map(|p| (input.shapes[p.shape].popcount(), 1))
.reduce(|(o_a, pc_a), (o_b, pc_b)| (o_a + o_b, pc_a + pc_b))
.unwrap();
if occupied_area > area {
// definitely impossible
continue;
}
let available_3x3s = (t.area.width() / 3) * (t.area.height() / 3);
if available_3x3s >= present_count {
// definitely_possible
count += 1;
continue;
}
if input
.place_next(t.clone(), 0, &mut HashSet::new())
.is_some()
{
count += 1;
continue;
}
}
@@ -205,7 +193,7 @@ fn part1(input: &PresentsProblem) -> u64 {
}
#[aoc(day12, part2)]
fn part2(input: &PresentsProblem) -> u64 {
fn part2(_input: &PresentsProblem) -> u64 {
0
}
@@ -251,12 +239,12 @@ mod tests {
#[rstest]
#[case(EXAMPLE, 0)]
fn part1_example(#[case] input: &str, #[case] expected: u64) {
assert_eq!(part1(&parse(EXAMPLE)), 2);
assert_eq!(part1(&parse(input)), expected);
}
#[rstest]
#[case(EXAMPLE, 0)]
fn part2_example(#[case] input: &str, #[case] expected: u64) {
assert_eq!(part2(&parse(EXAMPLE)), 0);
assert_eq!(part2(&parse(input)), expected);
}
}