Generalize 2024 day 18 to allow solving the example

Author: ictrobot

crates/year2024/examples/day18_example0.txt

@@ -0,0 +1,25 @@
+5,4
+4,2
+4,5
+3,0
+2,1
+6,3
+2,4
+1,5
+0,6
+3,3
+2,6
+5,1
+1,2
+5,5
+2,5
+6,5
+1,4
+0,4
+6,4
+1,1
+6,1
+1,0
+0,5
+1,6
+2,0

crates/year2024/src/day18.rs

@@ -6,85 +6,96 @@ use utils::prelude::*;
 /// Finding when the path through a grid is blocked.
 #[derive(Clone, Debug)]
 pub struct Day18 {
-    blocked_at: [[u16; WIDTH]; WIDTH],
-    fallen: u16,
+    blocked_at: Vec<u16>,
+    size: usize,
+    start_idx: usize,
+    end_idx: usize,
+    part1_fallen: u16,
+    total_fallen: u16,
 }
 
-const MAX_COORD: usize = 70;
-const WIDTH: usize = MAX_COORD + 1;
-
 impl Day18 {
-    pub fn new(input: &str, _: InputType) -> Result<Self, InputError> {
-        let mut blocked_at = [[u16::MAX; WIDTH]; WIDTH];
+    pub fn new(input: &str, input_type: InputType) -> Result<Self, InputError> {
+        let (max_coord, part1_fallen) = match input_type {
+            InputType::Example => (6, 12),
+            InputType::Real => (70, 1024),
+        };
+        // +1 as max_coord is inclusive, +2 for padding on each side
+        let size = max_coord + 3;
+
+        let mut blocked_at = vec![u16::MAX; size * size];
+        for i in 0..size {
+            blocked_at[i] = 0; // Top
+            blocked_at[(size - 1) * size + i] = 0; // Bottom
+            blocked_at[i * size] = 0; // Left
+            blocked_at[i * size + (size - 1)] = 0; // Right
+        }
+
         let mut fallen = 0;
-        for item in parser::number_range(0..=MAX_COORD)
-            .then(parser::number_range(0..=MAX_COORD).with_prefix(b','))
+        for item in parser::number_range(0..=max_coord)
+            .then(parser::number_range(0..=max_coord).with_prefix(b','))
             .map(|(x, y)| Point2D { x, y })
             .with_suffix(parser::eol())
             .parse_iterator(input)
         {
             let pos = item?;
-            if blocked_at[pos.x][pos.y] == u16::MAX {
-                blocked_at[pos.x][pos.y] = fallen;
+            if blocked_at[(pos.y + 1) * size + (pos.x + 1)] == u16::MAX {
+                blocked_at[(pos.y + 1) * size + (pos.x + 1)] = fallen;
                 fallen += 1;
             } else {
                 return Err(InputError::new(input, 0, "duplicate position in input"));
             }
         }
 
-        Ok(Self { blocked_at, fallen })
+        Ok(Self {
+            blocked_at,
+            size,
+            start_idx: size + 1,
+            end_idx: (max_coord + 1) * size + (max_coord + 1),
+            part1_fallen,
+            total_fallen: fallen,
+        })
     }
 
     #[must_use]
     pub fn part1(&self) -> u32 {
-        self.minimum_steps(1024).expect("no solution found")
-    }
-
-    fn minimum_steps(&self, fallen: u16) -> Option<u32> {
-        let mut blocked_at = self.blocked_at;
+        let mut blocked_at = self.blocked_at.clone();
         let mut queue = VecDeque::new();
-        queue.push_back((Point2D::new(0, 0), 0));
+        queue.push_back((self.start_idx, 0));
 
         while let Some((pos, steps)) = queue.pop_front() {
-            if pos == Point2D::new(MAX_COORD, MAX_COORD) {
-                return Some(steps);
+            if pos == self.end_idx {
+                return steps;
             }
 
-            if pos.x > 0 && blocked_at[pos.x - 1][pos.y] >= fallen {
-                queue.push_back((Point2D::new(pos.x - 1, pos.y), steps + 1));
-                blocked_at[pos.x - 1][pos.y] = 0;
-            }
-            if pos.x < MAX_COORD && blocked_at[pos.x + 1][pos.y] >= fallen {
-                queue.push_back((Point2D::new(pos.x + 1, pos.y), steps + 1));
-                blocked_at[pos.x + 1][pos.y] = 0;
-            }
-            if pos.y > 0 && blocked_at[pos.x][pos.y - 1] >= fallen {
-                queue.push_back((Point2D::new(pos.x, pos.y - 1), steps + 1));
-                blocked_at[pos.x][pos.y - 1] = 0;
-            }
-            if pos.y < MAX_COORD && blocked_at[pos.x][pos.y + 1] >= fallen {
-                queue.push_back((Point2D::new(pos.x, pos.y + 1), steps + 1));
-                blocked_at[pos.x][pos.y + 1] = 0;
+            for next in [pos - self.size, pos + 1, pos + self.size, pos - 1] {
+                if blocked_at[next] >= self.part1_fallen {
+                    queue.push_back((next, steps + 1));
+                    blocked_at[next] = 0;
+                }
             }
         }
 
-        None
+        panic!("no solution found")
     }
 
     #[must_use]
     pub fn part2(&self) -> String {
-        let mut blocked_at = self.blocked_at;
-        let mut reachable = vec![None; self.fallen as usize];
-        let mut fallen = self.fallen;
-        let mut next = Point2D::new(0, 0);
+        let mut blocked_at = self.blocked_at.clone();
+        let mut reachable = vec![None; self.total_fallen as usize];
+        let mut fallen = self.total_fallen;
+        let mut next = self.start_idx;
         loop {
             // Recursively flood fill the reachable grid spaces, tracking which grid spaces would
             // be reachable at a lower number of fallen bytes.
-            if Self::fill(next, fallen, &mut blocked_at, &mut reachable).is_break() {
-                if next == Point2D::new(0, 0) {
+            if self
+                .fill(next, fallen, &mut blocked_at, &mut reachable)
+                .is_break()
+            {
+                if fallen == self.total_fallen {
                     panic!("path is never blocked");
                 }
-                return format!("{},{}", next.x, next.y);
+                return format!("{},{}", (next % self.size) - 1, (next / self.size) - 1);
             }
 
             // No path to the end. Decrease fallen to the value blocking the highest reachable grid
@@ -98,31 +109,29 @@ impl Day18 {
     }
 
     fn fill(
-        pos: Point2D<usize>,
+        &self,
+        pos: usize,
         fallen: u16,
-        blocked_at: &mut [[u16; 71]; 71],
-        reachable: &mut [Option<Point2D<usize>>],
+        blocked_at: &mut [u16],
+        reachable: &mut [Option<usize>],
     ) -> ControlFlow<()> {
-        if pos == Point2D::new(MAX_COORD, MAX_COORD) {
+        if pos == self.end_idx {
             return ControlFlow::Break(());
         }
 
-        for dir in [Point2D::UP, Point2D::RIGHT, Point2D::DOWN, Point2D::LEFT] {
-            let next = pos.wrapping_add_signed(dir);
-            if next.x > MAX_COORD || next.y > MAX_COORD {
-                continue;
-            }
-
-            if blocked_at[next.x][next.y] >= fallen {
-                blocked_at[next.x][next.y] = 0;
-                Self::fill(next, fallen, blocked_at, reachable)?;
-            } else if blocked_at[next.x][next.y] > 0 {
-                reachable[blocked_at[next.x][next.y] as usize] = Some(next);
+        for next in [pos - self.size, pos + 1, pos + self.size, pos - 1] {
+            if blocked_at[next] >= fallen {
+                blocked_at[next] = 0;
+                self.fill(next, fallen, blocked_at, reachable)?;
+            } else if blocked_at[next] > 0 {
+                reachable[blocked_at[next] as usize] = Some(next);
             }
         }
 
         ControlFlow::Continue(())
     }
 }
 
-examples!(Day18 -> (u32, &'static str) []);
+examples!(Day18 -> (u32, &'static str) [
+    {file: "day18_example0.txt", part1: 22, part2: "6,1"},
+]);