day 20: 100ms -> 10ms; vec instead of hashmap

Author: tomasnyberg

README.md

@@ -1,40 +1,40 @@
 ## Advent of code 2024
 My solutions for the 2024 Advent of Code event. All solutions are written in Rust, and are of questionable quality since it's my first time using the language.
-The code is reasonably performant however and solves all problems in < 300 ms (see benchmarks below).
+The code is reasonably performant however and solves all problems in ~ 200 ms (see benchmarks below).
 
 ### Benchmarks
 Results from `./run.sh` in WSL using a 2016 Asus ZenBook UX303 (Ryzen 7 5700U 1.8GHz, 16GB RAM)
 ```
 ----------------------------------------
 Day        Time (ms)       Cumulative (ms)
 ----------------------------------------
-1          0.30            0.30
-2          0.53            0.83
-3          0.16            0.99
-4          0.55            1.54
-5          1.71            3.25
-6          24.98           28.23
-7          13.11           41.34
-8          0.38            41.72
-9          2.40            44.13
-10         0.57            44.70
-11         7.81            52.50
-12         2.60            55.11
-13         1.41            56.52
-14         53.28           109.80
-15         2.51            112.31
-16         31.24           143.55
-17         0.05            143.60
-18         0.57            144.17
-19         1.87            146.04
-20         70.11           216.14
-21         10.96           227.11
-22         20.79           247.89
-23         25.34           273.23
-24         0.31            273.54
-25         0.07            273.61
+1          0.21            0.21
+2          0.46            0.66
+3          0.06            0.72
+4          0.53            1.25
+5          1.62            2.87
+6          22.79           25.65
+7          12.82           38.47
+8          0.44            38.91
+9          2.64            41.55
+10         0.50            42.05
+11         7.65            49.70
+12         2.65            52.34
+13         1.75            54.09
+14         52.70           106.79
+15         2.51            109.29
+16         30.36           139.66
+17         0.05            139.71
+18         0.56            140.26
+19         1.91            142.17
+20         10.85           153.02
+21         10.69           163.71
+22         19.20           182.92
+23         25.09           208.01
+24         0.28            208.28
+25         0.07            208.35
 ----------------------------------------
-Total                      273.61
+Total                      208.35
 ```
 
 ### Requirements

src/day20.rs

@@ -1,5 +1,5 @@
 use rayon::prelude::*;
-use std::collections::{HashMap, VecDeque};
+use std::collections::VecDeque;
 
 const DIRS4: [(i32, i32); 4] = [(1, 0), (0, 1), (0, -1), (-1, 0)];
 
@@ -9,31 +9,46 @@ pub struct Pos {
 }
 
 pub fn find_cheats(
-    from_start: &HashMap<(usize, usize), i32>,
-    from_end: &HashMap<(usize, usize), i32>,
+    from_start: &[Vec<i32>],
+    from_end: &[Vec<i32>],
     e: &Pos,
     n: i32,
     skips_allowed: i32,
 ) -> i32 {
-    let end_steps = from_start[&(e.i, e.j)];
+    let end_steps = from_start[e.i][e.j];
     let threshold = if n > 50 { 100 } else { 50 };
+
     from_start
         .par_iter()
-        .map(|(&(i, j), &_v)| {
+        .enumerate()
+        .map(|(i, row)| {
             let mut local_result = 0;
-            let steps = from_start[&(i, j)];
-            for di in -20..21_i32 {
-                for dj in (di.abs() - 20)..(21 - di.abs()) {
-                    let (oi, oj) = (i as i32 + di, j as i32 + dj);
-                    if from_end.contains_key(&(oi as usize, oj as usize)) {
-                        let d = di.abs() + dj.abs();
-                        if d > skips_allowed {
-                            continue;
-                        }
-                        let total = steps + from_end[&(oi as usize, oj as usize)] + d;
-                        let saved = end_steps - total;
-                        if saved >= threshold {
-                            local_result += 1;
+            for (j, &steps) in row.iter().enumerate() {
+                if steps == -1 {
+                    continue;
+                }
+                for di in -20..21_i32 {
+                    for dj in (di.abs() - 20)..(21 - di.abs()) {
+                        let oi = i as i32 + di;
+                        let oj = j as i32 + dj;
+                        if oi >= 0
+                            && oi < from_end.len() as i32
+                            && oj >= 0
+                            && oj < from_end[0].len() as i32
+                        {
+                            let oi = oi as usize;
+                            let oj = oj as usize;
+                            if from_end[oi][oj] != -1 {
+                                let d = di.abs() + dj.abs();
+                                if d > skips_allowed {
+                                    continue;
+                                }
+                                let total = steps + from_end[oi][oj] + d;
+                                let saved = end_steps - total;
+                                if saved >= threshold {
+                                    local_result += 1;
+                                }
+                            }
                         }
                     }
                 }
@@ -42,33 +57,35 @@ pub fn find_cheats(
         })
         .sum()
 }
-
 pub fn bfs(grid: &[Vec<char>], s: &Pos, e: &Pos) -> (i32, i32) {
-    let mut from_start: HashMap<(usize, usize), i32> = HashMap::new();
-    let mut from_end: HashMap<(usize, usize), i32> = HashMap::new();
-    let n = grid.len() as i32;
-    let m = grid[0].len() as i32;
+    let n = grid.len();
+    let m = grid[0].len();
+    let mut from_start = vec![vec![-1; m]; n];
+    let mut from_end = vec![vec![-1; m]; n];
+
     for iter in 0..2 {
         let mut steps = 0;
         let mut queue = VecDeque::new();
-        queue.push_back(if iter == 0 { (s.i, s.j) } else { (e.i, e.j) });
+        let start = if iter == 0 { (s.i, s.j) } else { (e.i, e.j) };
         let map = if iter == 0 {
             &mut from_start
         } else {
             &mut from_end
         };
+
+        queue.push_back(start);
         while !queue.is_empty() {
             let qlen = queue.len();
             for _ in 0..qlen {
                 let (i, j) = queue.pop_front().unwrap();
-                if map.contains_key(&(i, j)) {
+                if map[i][j] != -1 {
                     continue;
                 }
-                map.insert((i, j), steps);
+                map[i][j] = steps;
                 for (di, dj) in DIRS4.iter() {
                     let (ni, nj) = (i as i32 + di, j as i32 + dj);
-                    if (0..n).contains(&ni)
-                        && (0..m).contains(&nj)
+                    if (0..n as i32).contains(&ni)
+                        && (0..m as i32).contains(&nj)
                         && grid[ni as usize][nj as usize] != '#'
                     {
                         queue.push_back((ni as usize, nj as usize));
@@ -78,8 +95,9 @@ pub fn bfs(grid: &[Vec<char>], s: &Pos, e: &Pos) -> (i32, i32) {
             steps += 1;
         }
     }
-    let part_one = find_cheats(&from_start, &from_end, e, n, 2);
-    let part_two = find_cheats(&from_start, &from_end, e, n, 20);
+
+    let part_one = find_cheats(&from_start, &from_end, e, n as i32, 2);
+    let part_two = find_cheats(&from_start, &from_end, e, n as i32, 20);
     (part_one, part_two)
 }