fix: fix dijkstra all paths function and solve 16/2024

Author: manhunto

readme.md

@@ -26,7 +26,7 @@
 | [Day 13: Claw Contraption](src/solutions/year2024/day13.rs)       |   ⭐⭐   |            0.241 |            0.331 |
 | [Day 14: Restroom Redoubt](src/solutions/year2024/day14.rs)       |   ⭐⭐   |            0.172 |          102.252 |
 | [Day 15: Warehouse Woes](src/solutions/year2024/day15.rs)         |   ⭐⭐   |            7.226 |            9.084 |
-| [Day 16: Reindeer Maze](src/solutions/year2024/day16.rs)          |   ⭐    |            6.478 |                - |
+| [Day 16: Reindeer Maze](src/solutions/year2024/day16.rs)          |   ⭐⭐   |            6.478 |        22716.831 |
 | [Day 17: Chronospatial Computer](src/solutions/year2024/day17.rs) |   -    |                - |                - |
 | [Day 18: RAM Run](src/solutions/year2024/day18.rs)                |   ⭐⭐   |            2.487 |          204.885 |
 | [Day 19: Linen Layout](src/solutions/year2024/day19.rs)           |   ⭐⭐   |            2.923 |           22.751 |

src/solutions/year2024/day16.rs

@@ -2,10 +2,8 @@ use crate::solutions::Solution;
 use crate::utils::direction::Direction::East;
 use crate::utils::graphs::dijkstra::Dijkstra;
 use crate::utils::grid::Grid;
-use crate::utils::point::Point;
 use crate::utils::vector::Vector;
 use itertools::Itertools;
-use std::collections::{HashSet, VecDeque};
 
 pub struct Day16;
 
@@ -32,16 +30,6 @@ impl Solution for Day16 {
                 })
                 .collect_vec();
 
-            // let mut grid = grid.clone();
-            // grid.modify(vector.position(), 'S');
-            // for re in &result {
-            //     grid.modify(re.position(), 'O')
-            // }
-            //
-            // println!("{} - {}", vector, result.len());
-            // println!("{}", grid);
-            //
-
             result
         };
 
@@ -96,41 +84,14 @@ impl Solution for Day16 {
         let is_end = |vector: Vector| vector.position() == end;
         let dijkstra: Dijkstra<Vector> = Dijkstra::new(&adjacency, &cost, &is_end);
 
-        let paths = dijkstra.all_path(vec![start]);
-
-        let mut queue: VecDeque<Point> = VecDeque::from([end]);
-        let mut path: HashSet<Point> = HashSet::from([end]);
-
-        while let Some(current) = queue.pop_back() {
-            let before_ends = paths
-                .iter()
-                .filter_map(|(to, from)| {
-                    if to.position() == current {
-                        if let Some(from) = from {
-                            if !path.contains(&from.position()) {
-                                return Some(from.position());
-                            }
-                        }
-                    }
-
-                    None
-                })
-                .collect_vec();
-
-            path.extend(before_ends.clone());
-            queue.extend(before_ends);
-        }
-
-        // let mut grid = grid.clone();
-        // for re in &path {
-        //     grid.modify(*re, 'O')
-        // }
-
-        // println!("{}", grid);
-        //
-        // println!("{:?}", path.len());
+        let paths = dijkstra.all_paths(vec![start]);
 
-        path.len().to_string()
+        paths
+            .iter()
+            .flat_map(|path| path.iter().map(|p| p.position()))
+            .unique()
+            .count()
+            .to_string()
     }
 }
 
@@ -161,7 +122,6 @@ mod tests {
     }
 
     #[test]
-    #[ignore]
     fn part_two_example_1() {
         assert_eq!("45", Day16.part_two(FIRST_EXAMPLE));
     }
@@ -190,7 +150,6 @@ mod tests {
     }
 
     #[test]
-    #[ignore]
     fn part_two_example_2() {
         assert_eq!("64", Day16.part_two(SECOND_EXAMPLE));
     }

src/solutions/year2024/day21.rs

@@ -18,23 +18,22 @@ const NUM_PAD: &str = r#"789
 const NUM_PAD_ELEMENTS: [u8; 11] = [
     b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'A',
 ];
-const ARROW_PAD: &str = r#".^A
+const KEY_PAD: &str = r#".^A
 <v>"#;
-const ARROW_PAD_ELEMENTS: [u8; 5] = [b'^', b'v', b'<', b'>', b'A'];
+const KEY_PAD_ELEMENTS: [u8; 5] = [b'^', b'v', b'<', b'>', b'A'];
 
 pub struct Day21;
 
 impl Solution for Day21 {
     fn part_one(&self, input: &str) -> String {
-        let pads = vec![Pad::numeric(), Pad::arrow(), Pad::arrow()];
+        let pads = vec![Pad::numeric(), Pad::key(), Pad::key()];
 
         input
             .lines()
             .map(|line| {
                 let path_len = self.path_len(line, &pads);
                 let num: usize = line.trim_end_matches('A').parse().unwrap();
 
-                // println!("{} * {}", path_len, num);
                 num * path_len
             })
             .sum::<usize>()
@@ -60,14 +59,12 @@ impl Day21 {
 
         current.chars().count()
     }
+
     fn path_for_str(&self, code: &str, pad: &Pad) -> Vec<Key> {
         let code = "A".to_owned() + code;
-        let a_position = pad.position(b'A').unwrap();
 
         let neighbours = |p: Point| pad.adjacent(&p);
-        let distance = |p1: Point, p2: Point| {
-            p1.manhattan_distance(&p2) as usize + p2.manhattan_distance(&a_position) as usize
-        };
+        let distance = |_, _| 1;
 
         let a_star = AStarBuilder::init(&neighbours, &distance).build();
 
@@ -133,8 +130,8 @@ impl Pad {
         }
     }
 
-    fn arrow() -> Self {
-        let positions = Self::build_positions(ARROW_PAD, &ARROW_PAD_ELEMENTS);
+    fn key() -> Self {
+        let positions = Self::build_positions(KEY_PAD, &KEY_PAD_ELEMENTS);
         let adjacent = Self::build_adjacent(&positions);
 
         Self {
@@ -182,9 +179,10 @@ impl Pad {
 
 #[cfg(test)]
 mod tests {
-    use crate::solutions::year2024::day21::Key::Activate;
+    use crate::solutions::year2024::day21::Key::{Activate, Dir};
     use crate::solutions::year2024::day21::{Day21, Pad};
     use crate::solutions::Solution;
+    use crate::utils::direction::Direction::{East, North, South, West};
 
     const EXAMPLE: &str = r#"029A
 980A
@@ -201,20 +199,61 @@ mod tests {
     #[test]
     #[ignore]
     fn path_len() {
-        let pads = vec![Pad::numeric(), Pad::arrow(), Pad::arrow()];
+        let pads = vec![Pad::numeric(), Pad::key(), Pad::key()];
 
         assert_eq!(68, Day21.path_len("029A", &pads));
         assert_eq!(60, Day21.path_len("980A", &pads));
         assert_eq!(68, Day21.path_len("179A", &pads));
         assert_eq!(64, Day21.path_len("456A", &pads));
         assert_eq!(64, Day21.path_len("379A", &pads));
+        assert_eq!(78, Day21.path_len("739A", &pads));
     }
 
     #[test]
     fn path_for_str() {
+        let numeric = &Pad::numeric();
+        let key = &Pad::key();
+
+        assert_eq!(Day21.path_for_str("AA", numeric), vec![Activate, Activate]);
+        assert_eq!(
+            Day21.path_for_str("A1", numeric),
+            vec![Activate, Dir(North), Dir(West), Dir(West), Activate]
+        );
+        assert_eq!(
+            Day21.path_for_str("A4", numeric),
+            vec![
+                Activate,
+                Dir(North),
+                Dir(North),
+                Dir(West),
+                Dir(West),
+                Activate
+            ]
+        );
+        assert_eq!(
+            Day21.path_for_str("A7", numeric),
+            vec![
+                Activate,
+                Dir(North),
+                Dir(North),
+                Dir(North),
+                Dir(West),
+                Dir(West),
+                Activate
+            ]
+        );
         assert_eq!(
-            Day21.path_for_str("AA", &Pad::numeric()),
-            vec![Activate, Activate]
+            Day21.path_for_str("<A", key),
+            vec![
+                Dir(South),
+                Dir(West),
+                Dir(West),
+                Activate,
+                Dir(East),
+                Dir(East),
+                Dir(North),
+                Activate
+            ]
         );
     }
 }

src/utils/graphs/dijkstra.rs

@@ -1,5 +1,6 @@
 use crate::utils::graphs::state_utils::State;
-use std::collections::{BinaryHeap, HashMap};
+use std::cmp::Ordering;
+use std::collections::{BinaryHeap, HashMap, VecDeque};
 use std::fmt::Debug;
 use std::hash::Hash;
 
@@ -56,25 +57,27 @@ impl<'a, T> Dijkstra<'a, T> {
     /// It returns every possible visited node
     /// Even if there is a many possible ways to reach end
     /// FIXME: is not working in valid way
-    pub fn all_path(&self, starts: Vec<T>) -> HashMap<T, Option<T>>
+    pub fn all_paths(&self, starts: Vec<T>) -> Vec<VecDeque<T>>
     where
         T: Hash + Eq + PartialEq + Ord + Debug + Copy,
     {
         let mut current_costs: HashMap<T, usize> = HashMap::new();
         let mut heap = BinaryHeap::new();
-        let mut come_from = HashMap::new();
+        let mut come_from: HashMap<T, Vec<T>> = HashMap::new();
 
-        for start in starts {
+        for start in starts.clone() {
             current_costs.insert(start, 0);
             heap.push(State::new(start, 0));
-            come_from.insert(start, None);
+            come_from.insert(start, Vec::new());
         }
 
         let mut lowest: Option<usize> = None;
+        let mut end_nodes: Vec<T> = Vec::new();
 
         while let Some(State { cost, node }) = heap.pop() {
             if (self.is_end)(node) {
                 lowest = Some(cost);
+                end_nodes.push(node);
 
                 continue;
             }
@@ -87,14 +90,107 @@ impl<'a, T> Dijkstra<'a, T> {
                 let neighbour_cost = cost + (self.cost)(node, neighbour);
                 let current_neighbour_cost = current_costs.get(&neighbour).unwrap_or(&usize::MAX);
 
-                if neighbour_cost < *current_neighbour_cost {
-                    *current_costs.entry(neighbour).or_insert(usize::MAX) = neighbour_cost;
-                    come_from.insert(neighbour, Some(node));
-                    heap.push(State::new(neighbour, neighbour_cost));
+                match neighbour_cost.cmp(current_neighbour_cost) {
+                    Ordering::Less => {
+                        *current_costs.entry(neighbour).or_insert(usize::MAX) = neighbour_cost;
+                        come_from.entry(neighbour).or_default().push(node);
+                        heap.push(State::new(neighbour, neighbour_cost));
+                    }
+                    Ordering::Equal => {
+                        come_from.entry(neighbour).or_default().push(node);
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        self.build_paths(&come_from, starts, end_nodes)
+    }
+
+    fn build_paths(
+        &self,
+        come_from: &HashMap<T, Vec<T>>,
+        start_nodes: Vec<T>,
+        end_nodes: Vec<T>,
+    ) -> Vec<VecDeque<T>>
+    where
+        T: Hash + Eq + PartialEq + Ord + Debug + Copy,
+    {
+        let mut paths: Vec<VecDeque<T>> = Vec::new();
+
+        for start in start_nodes {
+            for end in &end_nodes {
+                Self::visit(
+                    start,
+                    *end,
+                    Vec::new(),
+                    VecDeque::new(),
+                    &mut paths,
+                    come_from,
+                );
+            }
+        }
+
+        paths
+    }
+
+    fn visit(
+        from: T,
+        end: T,
+        mut visited: Vec<T>,
+        mut path: VecDeque<T>,
+        paths: &mut Vec<VecDeque<T>>,
+        come_from: &HashMap<T, Vec<T>>,
+    ) where
+        T: Hash + Eq + PartialEq + Ord + Debug + Copy,
+    {
+        {
+            visited.push(from);
+            path.push_back(from);
+
+            if from == end {
+                paths.push(path.clone());
+
+                return;
+            }
+
+            for p in come_from
+                .iter()
+                .filter(|(_, froms)| froms.contains(&from))
+                .map(|(to, _)| to)
+            {
+                if !visited.contains(p) {
+                    Self::visit(*p, end, visited.clone(), path.clone(), paths, come_from);
                 }
             }
         }
+    }
+}
 
-        come_from
+#[cfg(test)]
+mod test {
+    use crate::utils::graphs::dijkstra::Dijkstra;
+    use std::collections::VecDeque;
+
+    #[test]
+    fn all_paths() {
+        let dijkstra = Dijkstra::new(
+            &|node: char| match node {
+                'A' => vec!['^', '>'],
+                '^' => vec!['A', 'v'],
+                '>' => vec!['A', 'v'],
+                'v' => vec!['^', '>', '<'],
+                '<' => vec!['v'],
+                _ => unreachable!("Invalid node"),
+            },
+            &|_: char, _: char| 1,
+            &|node: char| node == '<',
+        );
+
+        let paths = dijkstra.all_paths(vec!['A']);
+
+        assert_eq!(paths.len(), 2);
+        assert!(paths.contains(&VecDeque::from(vec!['A', '^', 'v', '<'])));
+        assert!(paths.contains(&VecDeque::from(vec!['A', '>', 'v', '<'])));
     }
 }