WIP

Author: clechasseur

aoclp/src/dij.rs

@@ -0,0 +1,75 @@
+use std::collections::{HashMap, HashSet};
+use std::hash::Hash;
+use std::iter::once;
+
+pub trait Graph<T> {
+    fn all_nodes(&self) -> impl Iterator<Item = T>;
+    fn neighbours(&self, node: &T) -> impl Iterator<Item = T>;
+    fn dist(&self, a: &T, b: &T) -> usize;
+    fn is_first_better(&self, _a: &T, _b: &T) -> bool {
+        false
+    }
+}
+
+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>,
+{
+    let mut q: HashSet<_> = graph
+        .all_nodes()
+        .chain(once(start.clone()))
+        .collect();
+    let mut dist: HashMap<_, _> = q
+        .iter()
+        .map(|n| (n.clone(), usize::MAX))
+        .collect();
+    let mut prev = HashMap::new();
+    dist.insert(start.clone(), 0);
+
+    while !q.is_empty() {
+        let u = q
+            .iter()
+            .min_by_key(|n| dist[n])
+            .cloned()
+            .unwrap();
+        if dist[&u] == usize::MAX {
+            break;
+        }
+
+        q.remove(&u);
+        graph
+            .neighbours(&u)
+            .for_each(|v| {
+                let alt = dist[&u] + graph.dist(&u, &v);
+                if alt < dist[&v] || (prev.contains_key(&v) && alt == dist[&v] && graph.is_first_better(&u, &prev[&v])) {
+                    dist.insert(v.clone(), 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,41 @@
+use std::collections::HashMap;
+use std::ops::Deref;
+use aoclp::positioning::pt::Pt;
+use aoclp::solvers_impl::input::safe_get_input_as_terrain;
+
+pub fn part_1() -> usize {
+    0
+}
+
+pub fn part_2() -> usize {
+    0
+}
+
+#[derive(Debug, Copy, Clone)]
+struct Tile(usize);
+
+impl Deref for Tile {
+    type Target = usize;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl From<char> for Tile {
+    fn from(c: char) -> Self {
+        Self(c.to_digit(10).unwrap() as usize)
+    }
+}
+
+#[derive(Debug)]
+struct Map {
+    tiles: HashMap<Pt, Tile>,
+}
+
+impl Default for Map {
+    fn default() -> Self {
+        let map = safe_get_input_as_terrain(2024, 10);
+        Self { tiles:  }
+    }
+}

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;