chore: y2024::day_10

Author: clechasseur

aoclp/src/dij.rs

@@ -0,0 +1,78 @@
+use std::collections::hash_map::Entry;
+use std::collections::{HashMap, HashSet};
+use std::hash::Hash;
+
+pub trait Graph<T> {
+    fn neighbours(&self, node: &T) -> impl Iterator<Item = T>;
+    fn dist(&self, a: &T, b: &T) -> usize {
+        let (_, _) = (a, b);
+        1
+    }
+}
+
+pub struct Output<T> {
+    pub dist: HashMap<T, usize>,
+    pub prev: HashMap<T, T>,
+}
+
+pub fn build<T, G>(graph: &G, start: T) -> Output<T>
+where
+    T: Clone + Eq + Hash,
+    G: Graph<T>,
+{
+    // https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
+
+    let mut dist = HashMap::new();
+    let mut prev = HashMap::new();
+    dist.insert(start.clone(), 0);
+
+    let mut q = HashSet::new();
+    q.insert(start.clone());
+
+    while !q.is_empty() {
+        let u = q
+            .iter()
+            .map(|n| (n.clone(), dist.get(n).copied().unwrap_or(usize::MAX)))
+            .min_by_key(|(_, u_dist)| *u_dist);
+        match u {
+            None => break,
+            Some((u, u_dist)) => {
+                q.remove(&u);
+                graph.neighbours(&u).for_each(|v| {
+                    let alt = u_dist + graph.dist(&u, &v);
+                    match dist.entry(v.clone()) {
+                        Entry::Vacant(e) => {
+                            q.insert(v.clone());
+                            e.insert(alt);
+                            prev.insert(v, u.clone());
+                        },
+                        Entry::Occupied(mut e) if alt < *e.get() => {
+                            e.insert(alt);
+                            prev.insert(v, u.clone());
+                        },
+                        _ => (),
+                    }
+                });
+            },
+        }
+    }
+
+    Output { dist, prev }
+}
+
+pub fn assemble_path<T>(prev: &HashMap<T, T>, start: &T, end: &T) -> impl Iterator<Item = T>
+where
+    T: Clone + Eq + Hash,
+{
+    let mut path = Vec::new();
+    let mut n = end.clone();
+    while n != *start {
+        path.push(n.clone());
+        n = match prev.get(&n) {
+            Some(p) => p.clone(),
+            None => break,
+        }
+    }
+    path.push(start.clone());
+    path.into_iter().rev()
+}

aoclp/src/lib.rs

@@ -1,6 +1,7 @@
 //! Helper library for Advent of Code.
 
 pub mod captures;
+pub mod dij;
 pub mod forth;
 pub mod functional;
 pub mod looping;

aoclp_solutions/src/lib.rs

@@ -10,6 +10,6 @@ pub mod y2025;
 
 build_solvers! {
     { 2017, [01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25] },
-    { 2024, [01, 02, 03, 04, 05, 06, 07, 08, 09] },
+    { 2024, [01, 02, 03, 04, 05, 06, 07, 08, 09, 10] },
     { 2025, [01, 02, 03, 04, 05, 06, 07] }
 }

aoclp_solutions/src/y2024/day_10.rs

@@ -0,0 +1,106 @@
+use std::collections::HashMap;
+
+use aoclp::dij;
+use aoclp::positioning::direction::four_points::Direction4;
+use aoclp::positioning::pt::{matrix_to_map, Pt};
+use aoclp::solvers_impl::input::safe_get_input_as_terrain;
+use strum::IntoEnumIterator;
+
+pub fn part_1() -> usize {
+    Map::default().trailheads().map(|h| h.score).sum()
+}
+
+pub fn part_2() -> usize {
+    Map::default().trailheads().map(|h| h.rating).sum()
+}
+
+#[derive(Debug, Copy, Clone)]
+struct Tile {
+    height: usize,
+}
+
+impl From<char> for Tile {
+    fn from(c: char) -> Self {
+        Self { height: c.to_digit(10).unwrap() as usize }
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+struct Trailhead {
+    start: Pt,
+    score: usize,
+    rating: usize,
+}
+
+#[derive(Debug)]
+struct Map {
+    heightmap: HashMap<Pt, usize>,
+}
+
+impl Map {
+    fn trailheads(&self) -> impl Iterator<Item = Trailhead> + use<'_> {
+        self.heightmap
+            .iter()
+            .filter(|(_, &t)| t == 0)
+            .filter_map(move |(&p, _)| {
+                let dist = dij::build(self, p).dist;
+                let score = dist.values().filter(|d| **d == 9).count();
+                if score == 0 {
+                    return None;
+                }
+
+                let mut cache = HashMap::new();
+                let trailhead = Trailhead {
+                    start: p,
+                    score,
+                    rating: dist
+                        .iter()
+                        .filter(|(_, d)| **d == 9)
+                        .map(|(&p, _)| Self::path_count(p, &dist, &mut cache))
+                        .sum(),
+                };
+                Some(trailhead)
+            })
+    }
+
+    fn path_count(p: Pt, dist: &HashMap<Pt, usize>, cache: &mut HashMap<Pt, usize>) -> usize {
+        if let Some(count) = cache.get(&p) {
+            return *count;
+        }
+
+        let p_dist = dist[&p];
+        if p_dist == 0 {
+            return 1;
+        }
+
+        let count = Direction4::iter()
+            .map(|d| p + d)
+            .filter(|n| dist.get(n).is_some_and(|d| *d == p_dist - 1))
+            .map(|n| Self::path_count(n, dist, cache))
+            .sum();
+        cache.insert(p, count);
+
+        count
+    }
+}
+
+impl dij::Graph<Pt> for Map {
+    fn neighbours(&self, node: &Pt) -> impl Iterator<Item = Pt> {
+        let height = self.heightmap[node];
+        Direction4::iter()
+            .map(|d| *node + d)
+            .filter(move |n| self.heightmap.get(n).is_some_and(|h| *h == height + 1))
+    }
+}
+
+impl Default for Map {
+    fn default() -> Self {
+        Self {
+            heightmap: matrix_to_map(
+                safe_get_input_as_terrain::<Tile>(2024, 10)
+                    .into_iter()
+                    .map(|y| y.into_iter().map(|t| t.height)),
+            ),
+        }
+    }
+}

aoclp_solutions/src/y2024/mod.rs

@@ -7,3 +7,4 @@ pub mod day_06;
 pub mod day_07;
 pub mod day_08;
 pub mod day_09;
+pub mod day_10;