284 lines
8.2 KiB
Rust
284 lines
8.2 KiB
Rust
use std::collections::{HashMap, HashSet, VecDeque};
|
|
|
|
pub fn run() {
|
|
let input = std::fs::read_to_string("input/day20.txt").unwrap();
|
|
let maze = Maze::from(&input, PortalField::create);
|
|
let part1 = maze.shortest_path();
|
|
println!("Part 1: {}", part1);
|
|
}
|
|
|
|
type C = i32;
|
|
type FieldFactory = fn(&MapPoint) -> Box<dyn Field>;
|
|
|
|
#[derive(Hash, Eq, PartialEq, Copy, Clone, Debug)]
|
|
struct MapPoint {
|
|
x: C,
|
|
y: C,
|
|
}
|
|
|
|
impl MapPoint {
|
|
fn of(x: C, y: C) -> Self {
|
|
MapPoint { x, y }
|
|
}
|
|
|
|
fn neighbors(self) -> Vec<MapPoint> {
|
|
vec![
|
|
MapPoint::of(self.x + 1, self.y),
|
|
MapPoint::of(self.x, self.y + 1),
|
|
MapPoint::of(self.x - 1, self.y),
|
|
MapPoint::of(self.x, self.y - 1),
|
|
]
|
|
}
|
|
}
|
|
|
|
#[derive(Hash, Eq, PartialEq, Copy, Clone, Debug)]
|
|
struct RealPoint {
|
|
x: C,
|
|
y: C,
|
|
level: usize,
|
|
}
|
|
|
|
impl RealPoint {
|
|
fn map_point(&self) -> MapPoint {
|
|
MapPoint { x: self.x, y: self.y }
|
|
}
|
|
}
|
|
|
|
impl RealPoint {
|
|
fn from(map_point: MapPoint, level: usize) -> Self {
|
|
RealPoint { x: map_point.x, y: map_point.y, level }
|
|
}
|
|
}
|
|
|
|
trait Field {
|
|
fn neighbors(&self, at_level: usize) -> Vec<RealPoint>;
|
|
fn set_label_partner(&mut self, point: MapPoint);
|
|
fn set_neighbors(&mut self, neighbors: Vec<MapPoint>);
|
|
fn create(point: &MapPoint) -> Box<dyn Field> where Self: Sized;
|
|
}
|
|
|
|
struct PortalField {
|
|
neighbors: Vec<MapPoint>,
|
|
}
|
|
|
|
impl PortalField {
|
|
fn new() -> Self {
|
|
PortalField { neighbors: vec![] }
|
|
}
|
|
}
|
|
|
|
impl Field for PortalField {
|
|
fn neighbors(&self, _: usize) -> Vec<RealPoint> {
|
|
self.neighbors.iter().map(|p| RealPoint::from(*p, 0)).collect()
|
|
}
|
|
|
|
fn set_label_partner(&mut self, point: MapPoint) {
|
|
self.neighbors.push(point);
|
|
}
|
|
|
|
fn set_neighbors(&mut self, neighbors: Vec<MapPoint>) {
|
|
self.neighbors = neighbors;
|
|
}
|
|
|
|
fn create(_: &MapPoint) -> Box<dyn Field> where Self: Sized {
|
|
Box::new(PortalField::new())
|
|
}
|
|
}
|
|
|
|
//impl Field for PortalField {
|
|
// fn neighbors(self, level: usize) -> Vec<Point> {
|
|
// if let Some((direction, p)) = self.dimension_neighbor {
|
|
// if direction == DimensionUp && level < 0 {
|
|
// let mut v = self.neighbors.clone();
|
|
// v.push(p);
|
|
// v
|
|
// } else {
|
|
// self.neighbors.clone()
|
|
// }
|
|
// } else {
|
|
// self.neighbors.clone()
|
|
// }
|
|
// }
|
|
//}
|
|
|
|
type FieldMap = HashMap<MapPoint, Box<dyn Field>>;
|
|
|
|
struct Maze {
|
|
map: FieldMap,
|
|
start: RealPoint,
|
|
finish: RealPoint,
|
|
}
|
|
|
|
impl Maze {
|
|
fn from(input: &String, field_factory: FieldFactory) -> Self {
|
|
let (moc, width, height) = Self::map_of_chars(input);
|
|
|
|
let mut map = Self::create_map_of_free_spots(&moc, field_factory);
|
|
Self::add_physical_neighbors(&mut map);
|
|
let labels = Self::labels(&moc, width, height);
|
|
Self::process_labels(&mut map, &labels);
|
|
let start = labels["AA"][0];
|
|
let finish = labels["ZZ"][0];
|
|
|
|
Maze { map, start: RealPoint::from(start, 0), finish: RealPoint::from(finish, 0) }
|
|
}
|
|
|
|
fn shortest_path(&self) -> usize {
|
|
bfs(&self.map, self.start, self.finish)
|
|
}
|
|
|
|
fn process_labels(map: &mut FieldMap, labels: &HashMap<String, Vec<MapPoint>>) {
|
|
for (label, points) in labels {
|
|
if label == "AA" || label == "ZZ" {
|
|
continue;
|
|
}
|
|
|
|
map.get_mut(&points[0]).unwrap().set_label_partner(points[1]);
|
|
map.get_mut(&points[1]).unwrap().set_label_partner(points[0]);
|
|
}
|
|
}
|
|
|
|
fn labels(moc: &HashMap<MapPoint, char>, width: C, height: C) -> HashMap<String, Vec<MapPoint>> {
|
|
let horizontal: Vec<(String, MapPoint)> = (0..width - 2)
|
|
.into_iter()
|
|
.flat_map(|x| {
|
|
(0..height).into_iter().flat_map(move |y| {
|
|
let mut triple = [
|
|
moc[&MapPoint::of(x, y)],
|
|
moc[&MapPoint::of(x + 1, y)],
|
|
moc[&MapPoint::of(x + 2, y)],
|
|
];
|
|
let left = Self::label(triple).map(|label| (label, MapPoint::of(x, y)));
|
|
triple.reverse();
|
|
let right = Self::label(triple).map(|label| (label, MapPoint::of(x + 2, y)));
|
|
vec![left, right]
|
|
})
|
|
})
|
|
.flatten()
|
|
.collect();
|
|
|
|
let vertical: Vec<(String, MapPoint)> = (0..width)
|
|
.into_iter()
|
|
.flat_map(|x| {
|
|
(0..height - 2).into_iter().flat_map(move |y| {
|
|
let mut triple = [
|
|
moc[&MapPoint::of(x, y)],
|
|
moc[&MapPoint::of(x, y + 1)],
|
|
moc[&MapPoint::of(x, y + 2)],
|
|
];
|
|
let left = Self::label(triple).map(|label| (label, MapPoint::of(x, y)));
|
|
triple.reverse();
|
|
let right = Self::label(triple).map(|label| (label, MapPoint::of(x, y + 2)));
|
|
vec![left, right]
|
|
})
|
|
})
|
|
.flatten()
|
|
.collect();
|
|
|
|
let mut result = HashMap::new();
|
|
for (s, p) in horizontal.into_iter().chain(vertical.into_iter()) {
|
|
if !result.contains_key(&s) {
|
|
result.insert(s.clone(), vec![]);
|
|
}
|
|
result.get_mut(&s).unwrap().push(p);
|
|
}
|
|
result
|
|
}
|
|
|
|
fn label(chars: [char; 3]) -> Option<String> {
|
|
if chars[0] == '.' && chars[1].is_alphabetic() && chars[2].is_alphabetic() {
|
|
let label = if chars[1] < chars[2] {
|
|
format!("{}{}", chars[1], chars[2])
|
|
} else {
|
|
format!("{}{}", chars[2], chars[1])
|
|
};
|
|
Some(label)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn add_physical_neighbors(map: &mut FieldMap) {
|
|
let points: HashSet<MapPoint> = map.keys().map(|p| *p).collect();
|
|
map.iter_mut().for_each(|(p, f)| {
|
|
let neighbors = p
|
|
.neighbors()
|
|
.into_iter()
|
|
.filter(|neighbor| points.contains(neighbor))
|
|
.collect();
|
|
f.set_neighbors(neighbors);
|
|
})
|
|
}
|
|
|
|
fn create_map_of_free_spots(moc: &HashMap<MapPoint, char>, field_factory: FieldFactory) -> FieldMap {
|
|
moc.keys()
|
|
.filter(|p| moc[p] == '.')
|
|
.map(|p| (*p, field_factory(p)))
|
|
.collect()
|
|
}
|
|
|
|
fn map_of_chars(input: &String) -> (HashMap<MapPoint, char>, C, C) {
|
|
let mut map: HashMap<MapPoint, char> = input
|
|
.lines()
|
|
.enumerate()
|
|
.flat_map(|(y, line)| {
|
|
line.chars()
|
|
.enumerate()
|
|
.map(move |(x, c)| (MapPoint::of(x as C, y as C), c))
|
|
})
|
|
.collect();
|
|
|
|
let width = map.keys().map(|p| p.x).max().unwrap() + 1;
|
|
let height = map.keys().map(|p| p.y).max().unwrap() + 1;
|
|
|
|
for x in 0..width {
|
|
for y in 0..height {
|
|
if !map.contains_key(&MapPoint::of(x, y)) {
|
|
map.insert(MapPoint::of(x, y), ' ');
|
|
}
|
|
}
|
|
}
|
|
(map, width, height)
|
|
}
|
|
}
|
|
|
|
fn bfs(map: &FieldMap, start: RealPoint, finish: RealPoint) -> usize {
|
|
let mut open: VecDeque<(RealPoint, usize)> = VecDeque::new();
|
|
let mut seen: HashSet<RealPoint> = HashSet::new();
|
|
|
|
open.push_back((start, 0));
|
|
|
|
while let Some((p, d)) = open.pop_front() {
|
|
if p == finish {
|
|
return d;
|
|
}
|
|
|
|
for neighbor in map[&p.map_point()].neighbors(p.level) {
|
|
if !seen.contains(&neighbor) {
|
|
open.push_back((neighbor, d + 1));
|
|
}
|
|
seen.insert(neighbor);
|
|
}
|
|
}
|
|
panic!("no path found")
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use crate::tasks::day20::{Field, Maze, PortalField};
|
|
|
|
#[test]
|
|
fn example1() {
|
|
let input = std::fs::read_to_string("input/day20_example1.txt").unwrap();
|
|
let maze = Maze::from(&input, PortalField::create);
|
|
assert_eq!(maze.shortest_path(), 23);
|
|
}
|
|
|
|
#[test]
|
|
fn result() {
|
|
let input = std::fs::read_to_string("input/day20.txt").unwrap();
|
|
let maze = Maze::from(&input, PortalField::create);
|
|
assert_eq!(maze.shortest_path(), 454);
|
|
}
|
|
}
|