Seeing how concerency can speed this up

Author: mark-meyer

2024/day_20/Cargo.lock

@@ -4,3 +4,4 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+rayon = "1.10.0"

2024/day_20/Cargo.toml

@@ -1,63 +1,60 @@
-use std::collections::{VecDeque, HashSet};
+use std::collections::{HashSet, VecDeque};
 
 pub enum Direction {
     North,
     East,
     South,
-    West
+    West,
 }
 
-const DIRECTIONS:[Direction; 4] = [
-    Direction::North, 
+const DIRECTIONS: [Direction; 4] = [
+    Direction::North,
     Direction::East,
     Direction::South,
-    Direction::West
+    Direction::West,
 ];
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
-pub struct Point{
+pub struct Point {
     row: usize,
-    col: usize
+    col: usize,
 }
 impl Point {
-    pub fn new(row: usize, col:usize) -> Self {
-        Point {row, col}
+    pub fn new(row: usize, col: usize) -> Self {
+        Point { row, col }
     }
     pub fn to_uv(&self) -> (isize, isize) {
         let (row, col) = (self.row as isize, self.col as isize);
         (row + col, row - col)
     }
 }
 
-pub struct Map{
+pub struct Map {
     width: usize,
     height: usize,
     start: Point,
     end: Point,
-    pub matrix: Vec<Vec<Option<usize>>>
+    pub matrix: Vec<Vec<Option<usize>>>,
 }
 
 impl Map {
-    fn get(&self, p:&Point) -> Option<usize>{
+    fn get(&self, p: &Point) -> Option<usize> {
         self.matrix[p.row][p.col]
     }
 
     pub fn neighbors(&self, p: &Point) -> impl Iterator<Item = Point> + '_ {
         let &Point { row, col } = p;
-        DIRECTIONS.iter().filter_map(move |d| {
-            
-            match d {
-                Direction::North if row > 0 => Some(Point::new(row - 1, col)),
-                Direction::West  if col > 0 => Some(Point::new(row,col - 1)),
-                Direction::South if row < self.height - 1 =>  Some(Point::new(row + 1, col)),
-                Direction::East  if col < self.width - 1 => Some(Point::new(row,col + 1)),
-                _ => None
-            }
+        DIRECTIONS.iter().filter_map(move |d| match d {
+            Direction::North if row > 0 => Some(Point::new(row - 1, col)),
+            Direction::West if col > 0 => Some(Point::new(row, col - 1)),
+            Direction::South if row < self.height - 1 => Some(Point::new(row + 1, col)),
+            Direction::East if col < self.width - 1 => Some(Point::new(row, col + 1)),
+            _ => None,
         })
     }
 
-    /// Perform BFS but skew the resulting path so 
-    /// equal Manhattan distances will be in an 
+    /// Perform BFS but skew the resulting path so
+    /// equal Manhattan distances will be in an
     /// axis-aligned box.
     pub fn bfs(&mut self) -> Option<Vec<((isize, isize), usize)>> {
         let mut seen = HashSet::new();
@@ -69,11 +66,11 @@ impl Map {
             self.matrix[p.row][p.col] = Some(dist);
 
             path.push((p.to_uv(), dist));
-            if p == self.end { 
-               return Some(path);
+            if p == self.end {
+                return Some(path);
             }
             for neighbor in self.neighbors(&p) {
-                if !seen.contains(&(neighbor)) && self.get(&neighbor).is_some(){
+                if !seen.contains(&(neighbor)) && self.get(&neighbor).is_some() {
                     seen.insert(neighbor);
                     queue.push_back((neighbor, dist + 1));
                 }
@@ -84,30 +81,31 @@ impl Map {
 }
 
 impl From<&String> for Map {
-    fn from(s:&String) -> Self {
+    fn from(s: &String) -> Self {
         let mut start = None;
         let mut end = None;
-        let m:Vec<Vec<Option<usize>>> = s.split("\n")
-        .enumerate()
-        .map(|(row, line)| {
-            line.chars()
+        let m: Vec<Vec<Option<usize>>> = s
+            .split("\n")
             .enumerate()
-            .map(|(col, c)| {
-                match c {
-                    '#' => None,
-                    '.' => Some(usize::MAX),
-                    'S' => {
-                        start = Some(Point{row, col});
-                        Some(0)
-                    },
-                    'E' => {
-                        end = Some(Point{row, col});
-                        Some(usize::MAX)
-                    }
-                    _ => panic!("Debis on the field!!")
-                }
-            }).collect()
-        }).collect();
+            .map(|(row, line)| {
+                line.chars()
+                    .enumerate()
+                    .map(|(col, c)| match c {
+                        '#' => None,
+                        '.' => Some(usize::MAX),
+                        'S' => {
+                            start = Some(Point { row, col });
+                            Some(0)
+                        }
+                        'E' => {
+                            end = Some(Point { row, col });
+                            Some(usize::MAX)
+                        }
+                        _ => panic!("Debis on the field!!"),
+                    })
+                    .collect()
+            })
+            .collect();
         Map {
             start: start.unwrap(),
             end: end.unwrap(),

2024/day_20/src/lib.rs

@@ -1,41 +1,52 @@
-use std::fs;
+use rayon::prelude::*;
 use std::cmp::max;
+use std::fs;
+
 use day_20::*;
 
 /// points are (u,v) points to skew them to manhattan distance is axis aligned.
-fn find_cheats(uv_points:&[((isize, isize), usize)], cheat_length: usize, min_savings:usize) -> usize{
-    let mut left = 0;
-    let mut right = 1;
+fn find_cheats(
+    uv_points: &[((isize, isize), usize)],
+    cheat_length: usize,
+    min_savings: usize,
+) -> usize {
     let len = uv_points.len();
-    let mut total = 0;
-
-    for &((u, v), start_dist) in uv_points {
-
-        while  right < len - 1 && uv_points[right].0.0 < u + 1 + cheat_length as isize {
-            right += 1;
-        }
-        while  uv_points[left].0.0 < u - cheat_length  as isize {
-            left += 1;
-        }
-        for  &((u_next, v_next), end_dist) in &uv_points[left..right+1] {
-            let cheat = max(v.abs_diff(v_next), u.abs_diff(u_next));   // manhattan distance between the two points
-
-            if cheat <= cheat_length                                   // don't go through too many walls
-            && start_dist + cheat < end_dist                           // the cheat is actually an improvement
-            && end_dist.abs_diff(start_dist) - cheat >= min_savings {  // avoid counting tiny savings
-                total += 1;
-            } 
-        }
-    }
-    total
+
+    uv_points
+        .par_iter()
+        .enumerate()
+        .map(|(i, &((u, v), start_dist))| {
+            let mut left = i;
+            let mut right = i;
+
+            while right < len - 1 && uv_points[right + 1].0 .0 < u + 1 + cheat_length as isize {
+                right += 1;
+            }
+
+            while left > 0 && uv_points[left - 1].0 .0 >= u - cheat_length as isize {
+                left -= 1;
+            }
+
+            uv_points[left..=right]
+                .iter()
+                .filter(|&&((u_next, v_next), end_dist)| {
+                    let cheat = max(v.abs_diff(v_next), u.abs_diff(u_next)); // Manhattan distance
+                    cheat <= cheat_length
+                        && start_dist + cheat < end_dist
+                        && end_dist.abs_diff(start_dist) - cheat >= min_savings
+                })
+                .count()
+        })
+        .sum()
 }
+
 fn main() {
     let s = fs::read_to_string("data.txt").expect("no map found?");
     let mut map = Map::from(&s);
-    let mut uv_path =  map.bfs().unwrap();
+    let mut uv_path = map.bfs().unwrap();
 
     uv_path.sort_by_key(|((u, _v), _dist)| *u);
-    
+
     let part_one = find_cheats(&uv_path, 2, 100);
     println!("Part one: {}", part_one);