feat(11/2025): add cache for counting all paths and solve second part

Author: manhunto

readme.md

@@ -21,7 +21,7 @@
 | [Day 8: Playground](src/solutions/year2025/day08.rs)          |   ⭐⭐   |           46.993 |           44.599 |
 | [Day 9: Movie Theater](src/solutions/year2025/day09.rs)       |   ⭐    |            0.387 |                - |
 | [Day 10: Factory](src/solutions/year2025/day10.rs)            |        |                - |                - |
-| [Day 11: Reactor](src/solutions/year2025/day11.rs)            |   ⭐    |            0.692 |                - |
+| [Day 11: Reactor](src/solutions/year2025/day11.rs)            |   ⭐⭐   |            0.524 |            0.855 |
 
 # 2024
 

src/solutions/year2025/day11.rs

@@ -15,17 +15,13 @@ impl Solution for Day11 {
         let graph = self.parse(input);
         let all_paths: AllPaths<&str> = (&graph).into();
 
-        all_paths.paths(LABEL_YOU, LABEL_OUT).len().to_string()
+        all_paths.count_paths(LABEL_YOU, LABEL_OUT).to_string()
     }
 
     fn part_two(&self, input: &str) -> String {
         let graph = self.parse(input);
-        // todo reverse graph for directed only
-        // if undirected it is just the same?
         let all_paths: AllPaths<&str> = (&graph).into();
 
-        // find depth of every path and then pass it as parameter
-
         let svr_dac = all_paths.count_paths(LABEL_SVR, LABEL_DAC);
         let dac_fft = all_paths.count_paths(LABEL_DAC, LABEL_FFT);
         let fft_out = all_paths.count_paths(LABEL_FFT, LABEL_OUT);

src/utils/graphs/all_paths.rs

@@ -94,59 +94,42 @@ where
     where
         E: IsEnd<T>,
     {
-        self.count_paths_with_condition(start, end, |_: &VecDeque<T>| true)
-    }
-
-    pub fn count_paths_with_condition<E>(
-        &self,
-        start: T,
-        end: E,
-        should_count_path: impl Fn(&VecDeque<T>) -> bool,
-    ) -> usize
-    where
-        E: IsEnd<T>,
-    {
-        let mut visited = HashSet::new();
+        let mut cache: HashMap<T, usize> = HashMap::new();
         let mut path = VecDeque::new();
 
-        self.visit_and_count(start, &end, &mut visited, &mut path, &should_count_path)
+        self.visit_and_count(start, &end, &mut cache, &mut path)
     }
 
-    fn visit_and_count<E, F>(
+    fn visit_and_count<E>(
         &self,
         from: T,
         end: &E,
-        visited: &mut HashSet<T>,
+        cache: &mut HashMap<T, usize>,
         path: &mut VecDeque<T>,
-        should_count_path: &F,
     ) -> usize
     where
         E: IsEnd<T>,
-        F: Fn(&VecDeque<T>) -> bool,
     {
-        let mut count = 0usize;
-
-        visited.insert(from); // probably is not needed for graph
         path.push_back(from);
 
-        println!("{} {:?}", path.len(), path);
-
         if end.is_end(&from) {
-            if should_count_path(path) {
-                count += 1;
-            }
-        } else {
-            for p in (self.adjacency)(from) {
-                if !visited.contains(&p) {
-                    count += self.visit_and_count(p, end, visited, path, should_count_path);
-                }
-            }
+            return 1;
         }
 
+        if let Some(cache_value) = cache.get(&from) {
+            return *cache_value;
+        }
+
+        let result = (self.adjacency)(from)
+            .iter()
+            .map(|p| self.visit_and_count(*p, end, cache, path))
+            .sum::<usize>();
+
+        cache.insert(from, result);
+
         path.pop_back();
-        visited.remove(&from);
 
-        count
+        result
     }
 }