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) | 2774 |
 
 ## 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,128 @@
+//! # Reindeer Maze
+//!
+//! Part one is a normal [Dijkstra](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm)
+//! search from start to end.
+//!
+//! Part two we modify the search to check all possible paths. Then we perform a BFS *backwards*
+//! from the end to the finish, using the inverse cost to find all possible paths.
+use crate::util::grid::*;
+use crate::util::heap::*;
+use crate::util::point::*;
+
+type Input = (Grid<u8>, Point, Point);
+
+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();
+    (grid, start, end)
+}
+
+pub fn part1(input: &Input) -> u32 {
+    let (grid, ..) = input;
+    let &(_, start, end) = input;
+
+    let mut todo = MinHeap::new();
+    let mut seen = grid.same_size_with([u32::MAX; 4]);
+
+    todo.push(0, (start, 0));
+    seen[start][0] = 0;
+
+    while let Some((cost, (position, direction))) = todo.pop() {
+        if position == end {
+            // Stop search.
+            return 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 {
+            if grid[next_position] != b'#' && next_cost < seen[next_position][next_direction] {
+                todo.push(next_cost, (next_position, next_direction));
+                seen[next_position][next_direction] = next_cost;
+            }
+        }
+    }
+
+    unreachable!()
+}
+
+pub fn part2(input: &Input) -> usize {
+    let (grid, ..) = input;
+    let &(_, start, end) = input;
+
+    // Forwards Dijkstra
+    let mut todo = MinHeap::new();
+    let mut seen = grid.same_size_with([u32::MAX; 4]);
+    let mut lowest = u32::MAX;
+
+    todo.push(0, (start, 0));
+    seen[start][0] = 0;
+
+    while let Some((cost, (position, direction))) = todo.pop() {
+        if position == end {
+            lowest = lowest.min(cost);
+            // Keep searching.
+            continue;
+        }
+
+        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 {
+            if grid[next_position] != b'#' && next_cost < seen[next_position][next_direction] {
+                todo.push(next_cost, (next_position, next_direction));
+                seen[next_position][next_direction] = next_cost;
+            }
+        }
+    }
+
+    // Backwards BFS
+    let mut todo = Vec::new();
+    let mut path = grid.same_size_with(false);
+
+    for direction in 0..4 {
+        if seen[end][direction] == lowest {
+            todo.push((end, direction, lowest));
+        }
+    }
+
+    while let Some((position, direction, cost)) = todo.pop() {
+        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 {
+            if next_cost == seen[next_position][next_direction] {
+                todo.push((next_position, next_direction, next_cost));
+                seen[next_position][next_direction] = u32::MAX;
+            }
+        }
+    }
+
+    path.bytes.iter().filter(|&&b| b).count()
+}

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);
+}