day_18.rs

use hashbrown::HashSet;

use common::{Answer, Solution};
use nd_vec::{vector, Vector};

type Pos = nd_vec::Vec3<i32>;

pub struct Day18;

impl Solution for Day18 {
    fn name(&self) -> &'static str {
        "Boiling Boulders"
    }

    fn part_a(&self, input: &str) -> Answer {
        let world = World::parse(input);

        let mut open_faces = 0;

        for i in &world.points {
            open_faces += 6 - world.neighbors(i);
        }

        open_faces.into()
    }

    fn part_b(&self, input: &str) -> Answer {
        let world = World::parse(input);

        let outside = world.flood_fill(Vector::default());
        let mut out = 0;
        for i in &world.points {
            for j in NEIGHBORS {
                let n = *i + j;
                if !world.points.contains(&n) && outside.contains(&n) {
                    out += 1;
                }
            }
        }

        out.into()
    }
}

struct World {
    points: HashSet<Pos>,
}

const NEIGHBORS: [Pos; 6] = [
    vector!(1, 0, 0),
    vector!(-1, 0, 0),
    vector!(0, 1, 0),
    vector!(0, -1, 0),
    vector!(0, 0, 1),
    vector!(0, 0, -1),
];

impl World {
    fn parse(raw: &str) -> Self {
        Self {
            points: HashSet::from_iter(parse(raw)),
        }
    }

    fn neighbors(&self, point: &Pos) -> usize {
        let mut out = 0;

        for i in NEIGHBORS {
            out += self.points.contains(&(*point + i)) as usize;
        }

        out
    }

    fn bounds(&self) -> (Pos, Pos) {
        let mut min = vector!(i32::MAX, i32::MAX, i32::MAX);
        let mut max = vector!(i32::MIN, i32::MIN, i32::MIN);

        for i in &self.points {
            min = min.min(i);
            max = max.max(i);
        }

        (min, max)
    }

    fn flood_fill(&self, start: Pos) -> HashSet<Pos> {
        let bounds = self.bounds();
        let mut steam = HashSet::new();
        let mut new = vec![start];

        while let Some(s) = new.pop() {
            steam.insert(s);
            for n in NEIGHBORS {
                let n = s + n;
                if n.x() > bounds.1.x() + 1
                    || n.x() < bounds.0.x() - 1
                    || n.y() > bounds.1.y() + 1
                    || n.y() < bounds.0.y() - 1
                    || n.z() > bounds.1.z() + 1
                    || n.z() < bounds.0.z() - 1
                    || self.points.contains(&n)
                    || steam.contains(&n)
                    || new.contains(&n)
                {
                    continue;
                }

                new.push(n);
            }
        }

        steam
    }
}

fn parse(raw: &str) -> Vec<Pos> {
    let mut out = Vec::new();

    for i in raw.lines() {
        let mut parts = i.split(',');
        out.push(vector!(
            parts.next().unwrap().parse().unwrap(),
            parts.next().unwrap().parse().unwrap(),
            parts.next().unwrap().parse().unwrap()
        ));
    }

    out
}