18th day (find_shortest_path_cost optimization)

Author: majcn

data/examples/18.txt

@@ -24,4 +24,4 @@
 1,6
 2,0
 
-7,7,12
+EXAMPLE: 7,7,12

src/bin/18.rs

@@ -1,9 +1,6 @@
 advent_of_code::solution!(18);
 
-use std::collections::VecDeque;
-
 use advent_of_code::maneatingape::grid::*;
-use advent_of_code::maneatingape::hash::*;
 use advent_of_code::maneatingape::iter::*;
 use advent_of_code::maneatingape::parse::*;
 use advent_of_code::maneatingape::point::*;
@@ -15,7 +12,11 @@ enum Block {
 }
 
 fn parse_data(input: &str) -> (Vec<Point>, i32, i32, usize) {
-    let default_right = format!("{},{},{}", 71, 71, 1024);
+    const DEFAULT_WIDTH: usize = 71;
+    const DEFAULT_HEIGHT: usize = 71;
+    const DEFAULT_FIRST_TAKE: usize = 1024;
+
+    let default_right = format!("{DEFAULT_WIDTH},{DEFAULT_HEIGHT},{DEFAULT_FIRST_TAKE}",);
     let (left, right) = input.split_once("\n\n").unwrap_or((input, &default_right));
 
     let data = left
@@ -29,44 +30,38 @@ fn parse_data(input: &str) -> (Vec<Point>, i32, i32, usize) {
     (data, width, height, first_take as usize)
 }
 
-fn neighbors(grid: &Grid<Block>, position: Point, cost: u32) -> Vec<(Point, u32)> {
-    let mut result = Vec::with_capacity(4);
-
-    for direction in [LEFT, RIGHT, UP, DOWN] {
-        let n_position = position + direction;
-
-        if grid.contains(n_position) && matches!(grid[n_position], Block::Ok) {
-            result.push((n_position, cost + 1));
-        }
-    }
-
-    result
-}
-
-fn find_shortest_path_cost(grid: &Grid<Block>) -> u32 {
+fn find_shortest_path_cost(grid: &Grid<Block>) -> Option<u32> {
     let start_position = Point::new(0, 0);
     let end_position = Point::new(grid.width - 1, grid.height - 1);
 
-    let mut queue = VecDeque::new();
-    let mut g_score = FastMap::new();
+    let mut queue = std::collections::VecDeque::new();
+    let mut seen = Grid {
+        width: grid.width,
+        height: grid.height,
+        bytes: vec![false; (grid.width * grid.height) as usize],
+    };
 
-    queue.push_front((0, start_position));
-    g_score.insert(start_position, 0);
+    queue.push_front((start_position, 0));
+    seen[start_position] = true;
 
-    while let Some((cost, position)) = queue.pop_front() {
+    while let Some((position, cost)) = queue.pop_front() {
         if position == end_position {
-            return cost;
+            return Some(cost);
         }
 
-        for (n_position, n_cost) in neighbors(grid, position, cost) {
-            if n_cost < *g_score.get(&n_position).unwrap_or(&u32::MAX) {
-                g_score.insert(n_position, n_cost);
-                queue.push_back((n_cost, n_position));
+        for n_position in ORTHOGONAL.map(|o| position + o) {
+            if !grid.contains(n_position) || matches!(grid[n_position], Block::Corrupted) {
+                continue;
+            }
+
+            if !seen[n_position] {
+                queue.push_back((n_position, cost + 1));
+                seen[n_position] = true;
             }
         }
     }
 
-    u32::MAX
+    None
 }
 
 fn generate_grid(data: &[Point], width: i32, height: i32, n: usize) -> Grid<Block> {
@@ -86,7 +81,7 @@ fn generate_grid(data: &[Point], width: i32, height: i32, n: usize) -> Grid<Bloc
 pub fn part_one(input: &str) -> Option<u32> {
     let (data, width, height, first_take) = parse_data(input);
 
-    let result = find_shortest_path_cost(&generate_grid(&data, width, height, first_take));
+    let result = find_shortest_path_cost(&generate_grid(&data, width, height, first_take))?;
 
     Some(result)
 }
@@ -95,15 +90,14 @@ pub fn part_two(input: &str) -> Option<String> {
     let (data, width, height, first_take) = parse_data(input);
 
     let mut a = first_take;
-    let mut b = input.lines().count();
+    let mut b = data.len();
     while (b - a) > 1 {
         let c = (a + b) / 2;
 
-        let result = find_shortest_path_cost(&generate_grid(&data, width, height, c));
-        if result == u32::MAX {
-            b = c;
-        } else {
+        if find_shortest_path_cost(&generate_grid(&data, width, height, c)).is_some() {
             a = c;
+        } else {
+            b = c;
         }
     }
 
@@ -118,13 +112,15 @@ mod tests {
 
     #[test]
     fn test_part_one() {
-        let result = part_one(&advent_of_code::template::read_file("examples", DAY));
+        let input = advent_of_code::template::read_file("examples", DAY);
+        let result = part_one(&input);
         assert_eq!(result, Some(22));
     }
 
     #[test]
     fn test_part_two() {
-        let result = part_two(&advent_of_code::template::read_file("examples", DAY));
+        let input = advent_of_code::template::read_file("examples", DAY);
+        let result = part_two(&input);
         assert_eq!(result, Some(String::from("6,1")));
     }
 }