aoc: day20

Author: rhysd

adventofcode/2024/20.rs

@@ -0,0 +1,196 @@
+use std::cmp::Ordering;
+use std::collections::{BinaryHeap, HashMap};
+use std::env;
+use std::io::{self, BufRead};
+use std::ops::Deref;
+use std::rc::Rc;
+
+type Pos = (usize, usize);
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Cell {
+    Track,
+    Wall,
+}
+
+#[derive(Default)]
+struct PathNode(Pos, Option<Rc<PathNode>>);
+type Path = Rc<PathNode>;
+
+impl PathNode {
+    fn to_vec(&self) -> Vec<Pos> {
+        let mut v = vec![self.0];
+        let mut cur = self.1.as_ref();
+        while let Some(PathNode(pos, next)) = cur.map(|o| o.deref()) {
+            v.push(*pos);
+            cur = next.as_ref();
+        }
+        v.reverse();
+        v
+    }
+}
+
+struct Maze {
+    cells: Vec<Vec<Cell>>,
+    start: Pos,
+    end: Pos,
+    width: usize,
+    height: usize,
+    cache: HashMap<Pos, usize>,
+}
+
+impl Maze {
+    fn parse(lines: impl Iterator<Item = String>) -> Self {
+        let mut start = (0, 0);
+        let mut end = (0, 0);
+        let cells: Vec<Vec<_>> = lines
+            .enumerate()
+            .map(|(y, l)| {
+                l.chars()
+                    .enumerate()
+                    .map(|(x, c)| match c {
+                        'S' => {
+                            start = (x, y);
+                            Cell::Track
+                        }
+                        'E' => {
+                            end = (x, y);
+                            Cell::Track
+                        }
+                        '.' => Cell::Track,
+                        '#' => Cell::Wall,
+                        _ => unreachable!(),
+                    })
+                    .collect()
+            })
+            .collect();
+        let width = cells[0].len();
+        let height = cells.len();
+        Self { cells, start, end, width, height, cache: HashMap::new() }
+    }
+
+    fn memoize(&mut self, mut steps: usize, mut cur: &Path) {
+        loop {
+            let PathNode(pos, next) = &**cur;
+            self.cache.insert(*pos, steps);
+            if let Some(next) = next {
+                cur = next;
+                steps += 1;
+            } else {
+                return;
+            }
+        }
+    }
+
+    fn path(&mut self, start: Pos) -> Option<(usize, Option<Path>)> {
+        if let Some(&ret) = self.cache.get(&start) {
+            return Some((ret, None));
+        }
+
+        struct State {
+            pos: Pos,
+            steps: usize,
+            path: Path,
+        }
+
+        impl Ord for State {
+            fn cmp(&self, other: &Self) -> Ordering {
+                other.steps.cmp(&self.steps)
+            }
+        }
+
+        impl PartialOrd for State {
+            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+                Some(self.cmp(other))
+            }
+        }
+
+        impl PartialEq for State {
+            fn eq(&self, other: &Self) -> bool {
+                self.cmp(other) == Ordering::Equal
+            }
+        }
+
+        impl Eq for State {}
+
+        let mut queue = BinaryHeap::from([State {
+            pos: start,
+            steps: 0,
+            path: Rc::new(PathNode(start, None)),
+        }]);
+        let mut dist = HashMap::from([(start, 0)]);
+
+        while let Some(State { pos, steps, path }) = queue.pop() {
+            if let Some(&steps) = self.cache.get(&pos) {
+                self.memoize(steps, &path);
+                return Some((steps, None));
+            }
+
+            if pos == self.end {
+                self.memoize(0, &path);
+                return Some((steps, Some(path)));
+            }
+            if let Some(s) = dist.get(&pos) {
+                if *s < steps {
+                    continue;
+                }
+            }
+            let (x, y) = pos;
+            let steps = steps + 1;
+            for pos in [(x - 1, y), (x, y - 1), (x + 1, y), (x, y + 1)] {
+                let (x, y) = pos;
+                if self.cells[y][x] == Cell::Track
+                    && dist.get(&pos).map(|&s| steps < s).unwrap_or(true)
+                {
+                    let path = Rc::new(PathNode(pos, Some(path.clone())));
+                    dist.insert(pos, steps);
+                    queue.push(State { pos, steps, path });
+                }
+            }
+        }
+
+        None
+    }
+
+    fn solve(&mut self, max_dist: usize) -> usize {
+        let (orig, path) = self.path(self.start).unwrap();
+        let path = path.unwrap().to_vec();
+
+        let mut count = 0;
+        for (start, (ox, oy)) in path.into_iter().enumerate() {
+            for x in ox.saturating_sub(max_dist)..(ox + max_dist + 1).min(self.width) {
+                for y in oy.saturating_sub(max_dist)..(oy + max_dist + 1).min(self.height) {
+                    let dist = x.abs_diff(ox) + y.abs_diff(oy);
+                    if 2 <= dist && dist <= max_dist && self.cells[y][x] == Cell::Track {
+                        if let Some((extra, _)) = self.path((x, y)) {
+                            let steps = start + extra + dist; // Two steps for cheating through the wall
+                            if orig > steps && orig - steps >= 100 {
+                                count += 1;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        count
+    }
+}
+
+fn part1(lines: impl Iterator<Item = String>) {
+    let mut maze = Maze::parse(lines);
+    println!("{}", maze.solve(2));
+}
+
+fn part2(lines: impl Iterator<Item = String>) {
+    let mut maze = Maze::parse(lines);
+    println!("{}", maze.solve(20));
+}
+
+fn main() {
+    let lines = io::stdin().lock().lines().map(Result::unwrap);
+    match env::args().nth(1).as_deref() {
+        Some("1") => part1(lines),
+        Some("2") => part2(lines),
+        x => panic!("invalid argument: {:?}", x),
+    }
+}

adventofcode/2024/Cargo.toml

@@ -80,9 +80,9 @@ path = "18.rs"
 name = "19"
 path = "19.rs"
 
-# [[bin]]
-# name = "20"
-# path = "20.rs"
+[[bin]]
+name = "20"
+path = "20.rs"
 
 # [[bin]]
 # name = "21"