Solved day 15 of 2021

Author: marcdejonge

2021/Cargo.toml

@@ -16,7 +16,8 @@ rayon = "1.10.0"
 smallvec = "1"
 
 [profile.release]
-strip = true
-lto = true
-panic = "abort"
-debug = "none"
+# strip = true
+# lto = true
+# panic = "abort"
+# debug = "none"
+debug = true

2022/src/bin/day12.rs

@@ -34,37 +34,20 @@ impl From<u8> for Node {
 }
 
 fn calculate_part1(grid: &Grid<Node>) -> usize {
-    struct GraphPart1<'a> {
-        grid: &'a Grid<Node>,
-    }
-
-    impl SearchGraph for GraphPart1<'_> {
-        type Node = Location;
-        type Score = u32;
-
-        fn neighbours(&self, location: Location) -> impl Iterator<Item = (Location, u32)> {
-            let current_height = self.grid.get(location).unwrap().height;
-            Direction::ALL.into_iter().filter_map(move |dir| {
-                let next = location + dir;
-                let next_height = self.grid.get(next)?.height;
-                if next_height - current_height <= 1 {
-                    Some((next, 1))
-                } else {
-                    None
-                }
-            })
-        }
-    }
-
-    impl SearchGraphWithGoal for GraphPart1<'_> {
-        fn is_goal(&self, location: Location) -> bool { self.grid.get(location).unwrap().c == b'E' }
-    }
-
     let start_node = grid.find(|height| height.c == b'S').expect("Find the starting node");
-    a_star_search(&GraphPart1 { grid }, start_node)
-        .expect("Expected a path from S to E")
-        .len()
-        - 1
+    let end_node = grid.find(|height| height.c == b'E').expect("Find the ending node");
+    let graph = grid.search_graph(
+        end_node,
+        |_, current, next| {
+            if next.height - current.height <= 1 {
+                Some(1)
+            } else {
+                None
+            }
+        },
+        |_| 0,
+    );
+    a_star_search(&graph, start_node).expect("Expected a path from S to E").len() - 1
 }
 
 fn calculate_part2(grid: &Grid<Node>) -> usize {

shared/src/grid.rs

@@ -10,7 +10,7 @@ use nom::Err::Error;
 use nom::{AsBytes, AsChar, Compare, IResult, Input, Parser};
 use nom_parse_trait::ParseFrom;
 use std::fmt::{Debug, Formatter, Write};
-use std::ops::{Index, IndexMut, Range};
+use std::ops::{Add, Index, IndexMut, Range};
 
 #[derive(Clone, Hash, PartialEq)]
 pub struct Grid<T> {
@@ -470,6 +470,20 @@ impl<T> Grid<T> {
             .save_with_format(filename, image::ImageFormat::Png)
             .expect("Expect saving to not be a problem");
     }
+
+    pub fn search_graph<'a, FS, FH, S>(
+        &'a self,
+        goal: Location,
+        score_step: FS,
+        heuristic_score: FH,
+    ) -> GridGraph<'a, T, FS, FH>
+    where
+        FS: Fn(Location, &T, &T) -> Option<S>,
+        S: Copy + Default + Eq + Add<S, Output = S> + Ord,
+        FH: Fn(Vector<2, i32>) -> S,
+    {
+        GridGraph::<'a, T, FS, FH> { grid: self, goal, score_step, heuristic_score }
+    }
 }
 
 impl<T: Copy + Into<char>> Debug for Grid<T> {
@@ -726,3 +740,41 @@ where
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
 }
+
+pub struct GridGraph<'a, T, FS, FH> {
+    grid: &'a Grid<T>,
+    goal: Location,
+    score_step: FS,
+    heuristic_score: FH,
+}
+
+impl<'a, T, S, FS, FH> crate::search::SearchGraph for GridGraph<'a, T, FS, FH>
+where
+    FS: Fn(Location, &T, &T) -> Option<S>,
+    S: Copy + Default + Eq + Add<S, Output = S> + Ord,
+    FH: Fn(Vector<2, i32>) -> S,
+{
+    type Node = Location;
+    type Score = S;
+
+    fn neighbours(&self, current_loc: Location) -> impl Iterator<Item = (Location, S)> {
+        let current_val = self.grid.get(current_loc).unwrap();
+        self.grid.direct_neighbours(current_loc).flat_map(move |(dir, val)| {
+            let next_loc = current_loc + dir;
+            (self.score_step)(next_loc, current_val, val).map(|score| (next_loc, score))
+        })
+    }
+
+    fn expected_state_size(&self) -> usize { (self.grid.width() * self.grid.height()) as usize }
+}
+
+impl<'a, T, S, FS, FH> crate::search::SearchGraphWithGoal for GridGraph<'a, T, FS, FH>
+where
+    FS: Fn(Location, &T, &T) -> Option<S>,
+    S: Copy + Default + Eq + Add<S, Output = S> + Ord,
+    FH: Fn(Vector<2, i32>) -> S,
+{
+    fn is_goal(&self, curr: Location) -> bool { curr == self.goal }
+
+    fn heuristic(&self, curr: Location) -> Self::Score { (self.heuristic_score)(self.goal - curr) }
+}

shared/src/search.rs

@@ -11,6 +11,8 @@ pub trait SearchGraph {
     type Score: Copy + Default + Eq + Add<Self::Score, Output = Self::Score> + Ord;
 
     fn neighbours(&self, node: Self::Node) -> impl Iterator<Item = (Self::Node, Self::Score)>;
+
+    fn expected_state_size(&self) -> usize { 1000 }
 }
 
 pub trait SearchGraphWithGoal: SearchGraph {
@@ -40,9 +42,13 @@ pub fn a_star_search<G: SearchGraphWithGoal>(
     graph: &G,
     start_node: G::Node,
 ) -> Option<Vec<G::Node>> {
-    let mut current_states = HashMap::with_capacity_and_hasher(1000, FxBuildHasher::default());
+    let mut current_states =
+        HashMap::with_capacity_and_hasher(graph.expected_state_size(), FxBuildHasher::default());
     current_states.insert(start_node, (G::Score::default(), None)); // the value is the score + where the node came from
-    let mut open_set = PriorityQueue::with_capacity_and_hasher(1000, FxBuildHasher::default());
+    let mut open_set = PriorityQueue::with_capacity_and_hasher(
+        graph.expected_state_size(),
+        FxBuildHasher::default(),
+    );
     open_set.push(start_node, Reverse(G::Score::default())); // open_set uses the f_score as priority
 
     while let Some((node, _)) = open_set.pop() {