Day 18

Author: prevostc

src/bin/18.rs

@@ -4,17 +4,15 @@ use mygrid::{direction::ORTHOGONAL, grid::Grid, point::Point};
 
 advent_of_code::solution!(18);
 
-fn parse_points(input: &str) -> Vec<Point> {
-    input
-        .lines()
-        .filter(|line| !line.is_empty())
-        .map(|line| {
-            let (col, line) = line.split_once(',').unwrap();
-            Point::new(line.parse().unwrap(), col.parse().unwrap())
-        })
-        .collect()
+#[inline]
+fn parse_points<'a>(input: &'a str) -> impl Iterator<Item = Point> + 'a {
+    input.lines().filter(|line| !line.is_empty()).map(|line| {
+        let (col, line) = line.split_once(',').unwrap();
+        Point::new(line.parse().unwrap(), col.parse().unwrap())
+    })
 }
 
+#[inline]
 fn fill_min_dst_grid(grid: &Grid<char>, min_dst: &mut Grid<u32>, start: (Point, u32), end: Point) {
     let mut q = VecDeque::new();
     q.push_back(start);
@@ -41,7 +39,7 @@ fn fill_min_dst_grid(grid: &Grid<char>, min_dst: &mut Grid<u32>, start: (Point,
 fn find_shortest_path(input: &str, width: usize, height: usize, take: usize) -> Option<u32> {
     let mut grid = Grid::new(width, height, '.');
     let points = parse_points(input);
-    points.iter().take(take).for_each(|&p| {
+    points.take(take).for_each(|p| {
         grid[p] = '#';
     });
 
@@ -62,7 +60,7 @@ pub fn part_one(input: &str) -> Option<u32> {
 // work in reverse, fill them all in and find the first point that makes it possible to reach the end
 fn find_cutoff(input: &str, width: usize, height: usize, _initial_take: usize) -> Option<Point> {
     let mut grid = Grid::new(width, height, '.');
-    let points = parse_points(input);
+    let points = parse_points(input).collect::<Vec<_>>();
 
     points.iter().for_each(|&p| {
         grid[p] = '#';
@@ -75,31 +73,30 @@ fn find_cutoff(input: &str, width: usize, height: usize, _initial_take: usize) -
 
     fill_min_dst_grid(&grid, &mut min_dst, (start, 0), end);
 
-    let mut idx = points.len();
-    while min_dst[end] == u32::MAX {
-        idx -= 1;
-
-        let p = points[idx];
+    points.iter().rev().find_map(|&p| {
         grid[p] = '.';
 
         let min_neighbour_dst = ORTHOGONAL
             .iter()
             .map(|&dir| p + dir)
             .filter(|&p| grid.is_in_bounds(p))
-            .filter(|&p| grid[p] == '.')
             .map(|p| min_dst[p])
             .min()
             .unwrap_or(u32::MAX);
 
         if min_neighbour_dst == u32::MAX {
-            continue;
+            return None;
         }
         let dst = min_neighbour_dst + 1;
 
         fill_min_dst_grid(&grid, &mut min_dst, (p, dst), end);
-    }
 
-    Some(points[idx])
+        if min_dst[end] != u32::MAX {
+            return Some(p);
+        }
+
+        return None;
+    })
 }
 
 pub fn part_two(input: &str) -> Option<String> {