Day 16

Author: prevostc

src/bin/16.rs

@@ -1,58 +1,46 @@
+use object_pool::Pool;
 use std::collections::VecDeque;
 
 use mygrid::{
     direction::{Direction, DOWN, LEFT, RIGHT, UP},
     grid::Grid,
-    point::Point,
 };
 
 advent_of_code::solution!(16);
 
+#[inline]
+fn dir_to_index(dir: Direction) -> usize {
+    match dir {
+        RIGHT => 0,
+        DOWN => 1,
+        LEFT => 2,
+        UP => 3,
+        _ => unreachable!(),
+    }
+}
+
 pub fn part_one(input: &str) -> Option<u64> {
     let (grid, start) = Grid::new_from_str_capture_start(input, &|c| c, &|c| c == 'S');
-    let target_pos = grid
-        .iter_item_and_position()
-        .filter(|&(_, c)| *c == 'E')
-        .map(|(p, _)| p)
-        .next()
-        .unwrap();
-
-    #[derive(Debug, PartialEq, Eq)]
-    struct State {
-        pos: Point,
-        dir: Direction,
-        cost: u64,
-    }
+    let target_pos = grid.find_position_of(&'E').unwrap();
 
     let mut q = VecDeque::new();
-    q.push_back(State {
-        pos: start,
-        dir: RIGHT,
-        cost: 0,
-    });
+    q.push_back((start, RIGHT, 0));
 
     let mut best_cost_grid = Grid::new(grid.width, grid.height, [u64::MAX; 4]);
-    let dir_to_index = |d: Direction| match d {
-        RIGHT => 0,
-        DOWN => 1,
-        LEFT => 2,
-        UP => 3,
-        _ => unreachable!(),
-    };
 
-    while let Some(s) = q.pop_front() {
-        if s.pos == target_pos {
-            best_cost_grid[s.pos][dir_to_index(s.dir)] = s.cost;
+    while let Some((pos, dir, cost)) = q.pop_front() {
+        if pos == target_pos {
+            best_cost_grid[pos][dir_to_index(dir)] = cost;
             continue;
         }
 
-        let right = s.dir.rotate_clockwise();
-        let left = s.dir.rotate_counterclockwise();
+        let right = dir.rotate_clockwise();
+        let left = dir.rotate_counterclockwise();
 
         for &(pos, dir, cost) in [
-            (s.pos + s.dir, s.dir, s.cost + 1),
-            (s.pos + right, right, s.cost + 1000 + 1),
-            (s.pos + left, left, s.cost + 1000 + 1),
+            (pos + dir, dir, cost + 1),
+            (pos + right, right, cost + 1000 + 1),
+            (pos + left, left, cost + 1000 + 1),
         ]
         .iter()
         {
@@ -65,85 +53,54 @@ pub fn part_one(input: &str) -> Option<u64> {
             }
             best_cost_grid[pos][dir_to_index(dir)] = cost;
 
-            let new_state = State { pos, dir, cost };
-            q.push_back(new_state);
+            q.push_back((pos, dir, cost));
         }
     }
 
     let min_cost = *best_cost_grid[target_pos].iter().min().unwrap();
     Some(min_cost)
 }
 
-#[inline]
-fn dir_to_index(dir: Direction) -> usize {
-    match dir {
-        RIGHT => 0,
-        DOWN => 1,
-        LEFT => 2,
-        UP => 3,
-        _ => unreachable!(),
-    }
-}
-
 pub fn part_two(input: &str) -> Option<u64> {
     let (grid, start) = Grid::new_from_str_capture_start(input, &|c| c, &|c| c == 'S');
-    let target_pos = grid
-        .iter_item_and_position()
-        .filter(|&(_, c)| *c == 'E')
-        .map(|(p, _)| p)
-        .next()
-        .unwrap();
-
-    use object_pool::{Pool, Reusable};
-
-    struct State<'a> {
-        path: Reusable<'a, Vec<Point>>,
-        pos: Point,
-        dir: Direction,
-        cost: u64,
-    }
+    let target_pos = grid.find_position_of(&'E').unwrap();
 
     const PATH_CAPACITY: usize = 512;
     let path_pool = Pool::new(256, || Vec::with_capacity(PATH_CAPACITY));
     let mut path = path_pool.pull(|| Vec::with_capacity(PATH_CAPACITY));
     path.push(start);
 
     let mut q = VecDeque::new();
-    q.push_back(State {
-        path,
-        pos: start,
-        dir: RIGHT,
-        cost: 0,
-    });
+    q.push_back((path, start, RIGHT, 0));
 
     let base_false_grid = Grid::new(grid.width, grid.height, false);
     let mut best_spots_grid = base_false_grid.clone();
     let mut best_target_cost = u64::MAX;
     let mut best_cost_grid = Grid::new(grid.width, grid.height, [u64::MAX; 4]);
 
-    while let Some(mut s) = q.pop_front() {
-        if s.pos == target_pos {
-            if best_target_cost < s.cost {
+    while let Some((mut path, pos, dir, cost)) = q.pop_front() {
+        if pos == target_pos {
+            if best_target_cost < cost {
                 continue;
             }
 
             // reset best_spots_grid if we found a better path
-            if best_target_cost > s.cost {
+            if best_target_cost > cost {
                 best_spots_grid = base_false_grid.clone();
             }
 
-            for &p in s.path.iter() {
+            for &p in path.iter() {
                 best_spots_grid[p] = true;
             }
 
-            best_target_cost = s.cost;
+            best_target_cost = cost;
             continue;
         }
 
-        best_cost_grid[s.pos][dir_to_index(s.dir)] = s.cost;
+        best_cost_grid[pos][dir_to_index(dir)] = cost;
 
-        let right = s.dir.rotate_clockwise();
-        let left = s.dir.rotate_counterclockwise();
+        let right = dir.rotate_clockwise();
+        let left = dir.rotate_counterclockwise();
         let is_viable = |&(pos, dir, cost)| {
             if grid[pos] == '#' {
                 return false;
@@ -159,9 +116,9 @@ pub fn part_two(input: &str) -> Option<u64> {
         };
 
         let all_options = [
-            (s.pos + s.dir, s.dir, s.cost + 1),
-            (s.pos + left, left, s.cost + 1000 + 1),
-            (s.pos + right, right, s.cost + 1000 + 1),
+            (pos + dir, dir, cost + 1),
+            (pos + left, left, cost + 1000 + 1),
+            (pos + right, right, cost + 1000 + 1),
         ];
 
         let viable_options = [
@@ -177,11 +134,8 @@ pub fn part_two(input: &str) -> Option<u64> {
             1 => {
                 let idx = viable_options.iter().position(|&b| b).unwrap();
                 let (pos, dir, cost) = all_options[idx];
-                s.path.push(pos);
-                s.cost = cost;
-                s.pos = pos;
-                s.dir = dir;
-                q.push_back(s);
+                path.push(pos);
+                q.push_back((path, pos, dir, cost));
             }
             _ => viable_options
                 .iter()
@@ -193,15 +147,9 @@ pub fn part_two(input: &str) -> Option<u64> {
 
                     let (pos, dir, cost) = all_options[idx];
                     let mut new_path = path_pool.pull(|| Vec::with_capacity(PATH_CAPACITY));
-                    new_path.clone_from(&s.path);
+                    new_path.clone_from(&path);
                     new_path.push(pos);
-                    let new_state = State {
-                        path: new_path,
-                        pos,
-                        dir,
-                        cost,
-                    };
-                    q.push_back(new_state);
+                    q.push_back((new_path, pos, dir, cost));
                 }),
         }
     }