Year 2024 Day 16

Author: maneatingape

README.md

@@ -87,6 +87,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 13 | [Claw Contraption](https://adventofcode.com/2024/day/13) | [Source](src/year2024/day13.rs) | 14 |
 | 14 | [Restroom Redoubt](https://adventofcode.com/2024/day/14) | [Source](src/year2024/day14.rs) | 74 |
 | 15 | [Warehouse Woes](https://adventofcode.com/2024/day/15) | [Source](src/year2024/day15.rs) | 303 |
+| 16 | [Reindeer Maze](https://adventofcode.com/2024/day/16) | [Source](src/year2024/day16.rs) | 356 |
 
 ## 2023
 

benches/benchmark.rs

@@ -88,5 +88,5 @@ benchmark!(year2023
 
 benchmark!(year2024
     day01, day02, day03, day04, day05, day06, day07, day08, day09, day10, day11, day12, day13,
-    day14, day15
+    day14, day15, day16
 );

src/lib.rs

@@ -68,5 +68,5 @@ library!(year2023 "Restore global snow production."
 
 library!(year2024 "Locate the Chief Historian in time for the big Christmas sleigh launch."
     day01, day02, day03, day04, day05, day06, day07, day08, day09, day10, day11, day12, day13,
-    day14, day15
+    day14, day15, day16
 );

src/main.rs

@@ -142,5 +142,5 @@ run!(year2023
 
 run!(year2024
     day01, day02, day03, day04, day05, day06, day07, day08, day09, day10, day11, day12, day13,
-    day14, day15
+    day14, day15, day16
 );

src/year2024/day16.rs

@@ -0,0 +1,117 @@
+//! # Reindeer Maze
+//!
+//! Solves part one and part two simultaneously.
+//!
+//! Part one is a normal [Dijkstra](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm)
+//! search from start to end.
+//!
+//! Part two is a a BFS *backwards* from the end to the finish, tracing the cost exactly
+//! to find all possible paths. This reuses the cost information from the Dijkstra without
+//! requiring any extra state keeping for the paths.
+use crate::util::grid::*;
+use crate::util::point::*;
+use std::collections::VecDeque;
+
+type Input = (u32, usize);
+
+/// Clockwise order starting with facing right.
+const DIRECTIONS: [Point; 4] = [RIGHT, DOWN, LEFT, UP];
+
+pub fn parse(input: &str) -> Input {
+    let grid = Grid::parse(input);
+    let start = grid.find(b'S').unwrap();
+    let end = grid.find(b'E').unwrap();
+
+    // Forwards Dijkstra. This can almost be treated as a BFS since turns are so much more
+    // expensive than forward moves. The grid is 140 x 140 so there can never be more than 138
+    // moves in a straight line. Maintaining two queues keeps moves in order and is much faster
+    // than a heap.
+    let mut todo_first = VecDeque::with_capacity(1_000);
+    let mut todo_second = VecDeque::with_capacity(1_000);
+
+    // State is `(position, direction)`.
+    let mut seen = grid.same_size_with([u32::MAX; 4]);
+    let mut lowest = u32::MAX;
+
+    todo_first.push_back((start, 0, 0));
+    seen[start][0] = 0;
+
+    while lowest == u32::MAX {
+        while let Some((position, direction, cost)) = todo_first.pop_front() {
+            // Once we find the end node then stop. All paths of the same cost must be in
+            // this bucket, so have already been accounted for.
+            if position == end {
+                lowest = cost;
+                break;
+            }
+
+            // -1.rem_euclid(4) = 3
+            let left = (direction + 3) % 4;
+            let right = (direction + 1) % 4;
+            let next = [
+                (position + DIRECTIONS[direction], direction, cost + 1),
+                (position, left, cost + 1000),
+                (position, right, cost + 1000),
+            ];
+
+            for tuple @ (next_position, next_direction, next_cost) in next {
+                if grid[next_position] != b'#' && next_cost < seen[next_position][next_direction] {
+                    if next_direction == direction {
+                        todo_first.push_back(tuple);
+                    } else {
+                        todo_second.push_back(tuple);
+                    }
+                    seen[next_position][next_direction] = next_cost;
+                }
+            }
+        }
+
+        (todo_first, todo_second) = (todo_second, todo_first);
+    }
+
+    // Backwards BFS
+    let mut todo = VecDeque::new();
+    let mut path = grid.same_size_with(false);
+
+    // Lowest paths can arrive at end node in multiple directions.
+    for direction in 0..4 {
+        if seen[end][direction] == lowest {
+            todo.push_back((end, direction, lowest));
+        }
+    }
+
+    while let Some((position, direction, cost)) = todo.pop_front() {
+        path[position] = true;
+        if position == start {
+            continue;
+        }
+
+        // Reverse direction and subtract cost.
+        let left = (direction + 3) % 4;
+        let right = (direction + 1) % 4;
+        let next = [
+            (position - DIRECTIONS[direction], direction, cost - 1),
+            (position, left, cost - 1000),
+            (position, right, cost - 1000),
+        ];
+
+        for (next_position, next_direction, next_cost) in next {
+            // Trace our cost step by step so it will exactly match possible paths.
+            if next_cost == seen[next_position][next_direction] {
+                todo.push_back((next_position, next_direction, next_cost));
+                // Set cost back to `u32::MAX` to prevent redundant path explorations.
+                seen[next_position][next_direction] = u32::MAX;
+            }
+        }
+    }
+
+    (lowest, path.bytes.iter().filter(|&&b| b).count())
+}
+
+pub fn part1(input: &Input) -> u32 {
+    input.0
+}
+
+pub fn part2(input: &Input) -> usize {
+    input.1
+}

tests/test.rs

@@ -81,5 +81,5 @@ test!(year2023
 
 test!(year2024
     day01, day02, day03, day04, day05, day06, day07, day08, day09, day10, day11, day12, day13,
-    day14, day15
+    day14, day15, day16
 );

tests/year2024/day16.rs

@@ -0,0 +1,32 @@
+use aoc::year2024::day16::*;
+
+const EXAMPLE: &str = "\
+#################
+#...#...#...#..E#
+#.#.#.#.#.#.#.#.#
+#.#.#.#...#...#.#
+#.#.#.#.###.#.#.#
+#...#.#.#.....#.#
+#.#.#.#.#.#####.#
+#.#...#.#.#.....#
+#.#.#####.#.###.#
+#.#.#.......#...#
+#.#.###.#####.###
+#.#.#...#.....#.#
+#.#.#.#####.###.#
+#.#.#.........#.#
+#.#.#.#########.#
+#S#.............#
+#################";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(&input), 11048);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(&input), 64);
+}