Faster day 6

Author: prevostc

README.md

@@ -16,10 +16,10 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 | [Day 3](./src/bin/03.rs) | `222.9µs` | `246.5µs` |
 | [Day 4](./src/bin/04.rs) | `145.9µs` | `33.2µs` |
 | [Day 5](./src/bin/05.rs) | `66.0µs` | `188.7µs` |
-| [Day 6](./src/bin/06.rs) | `44.8µs` | `11.1ms` |
+| [Day 6](./src/bin/06.rs) | `48.5µs` | `4.2ms` |
 | [Day 7](./src/bin/07.rs) | `316.2µs` | `319.6µs` |
 
-**Total: 12.87ms**
+**Total: 5.98ms**
 <!--- benchmarking table --->
 
 ---

mygrid/src/point.rs

@@ -48,6 +48,29 @@ impl Point {
     pub fn min(&self, other: &Point) -> Self {
         Point::new(self.line.min(other.line), self.column.min(other.column))
     }
+
+    #[inline]
+    pub fn is_aligned(&self, other: &Point) -> bool {
+        self.line == other.line || self.column == other.column
+    }
+
+    #[inline]
+    pub fn is_between_inclusive(&self, a: &Point, b: &Point) -> bool {
+        if !self.is_aligned(a) || !self.is_aligned(b) || !a.is_aligned(b) {
+            return false;
+        }
+
+        let min_line = a.line.min(b.line);
+        let max_line = a.line.max(b.line);
+        let min_column = a.column.min(b.column);
+        let max_column = a.column.max(b.column);
+
+        let is_between_lines = (min_line..=max_line).contains(&self.line);
+        let is_between_columns = (min_column..=max_column).contains(&self.column);
+
+        (a.line == b.line && a.line == self.line && is_between_columns)
+            || (a.column == b.column && a.column == self.column && is_between_lines)
+    }
 }
 
 impl Hash for Point {
@@ -100,6 +123,49 @@ mod tests {
         assert_eq!(min.column, 1);
     }
 
+    #[test]
+    pub fn test_point_is_aligned() {
+        let point = Point::new(1, 2);
+        let other = Point::new(1, 3);
+        assert!(point.is_aligned(&other));
+
+        let point = Point::new(1, 2);
+        let other = Point::new(3, 1);
+        assert!(!point.is_aligned(&other));
+
+        let point = Point::new(1, 2);
+        let other = Point::new(1, 2);
+        assert!(point.is_aligned(&other));
+    }
+
+    #[test]
+    pub fn test_point_is_between_inclusive() {
+        let point = Point::new(1, 2);
+        let a = Point::new(0, 2);
+        let b = Point::new(2, 2);
+        assert!(point.is_between_inclusive(&a, &b));
+
+        let point = Point::new(1, 2);
+        let a = Point::new(1, 0);
+        let b = Point::new(1, 4);
+        assert!(point.is_between_inclusive(&a, &b));
+
+        let point = Point::new(1, 2);
+        let a = Point::new(0, 1);
+        let b = Point::new(2, 3);
+        assert!(!point.is_between_inclusive(&a, &b));
+
+        let point = Point::new(1, 2);
+        let a = Point::new(1, 2);
+        let b = Point::new(2, 3);
+        assert!(!point.is_between_inclusive(&a, &b));
+
+        let point = Point::new(1, 2);
+        let a = Point::new(2, 1);
+        let b = Point::new(3, 2);
+        assert!(!point.is_between_inclusive(&a, &b));
+    }
+
     // #[test]
     // pub fn test_infinite_grid_to_real_grid() {
     //     let point = Point::new(45, 20);

src/bin/06.rs

@@ -3,7 +3,9 @@ use mygrid::direction::{Direction, UP};
 use mygrid::grid::Grid;
 use mygrid::point::Point;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
-use rustc_hash::FxHashSet;
+use rustc_hash::{FxHashMap, FxHashSet};
+
+type JumpTable = FxHashMap<Guard, Guard>;
 
 #[derive(Default, Clone, PartialEq, Eq, Hash, Debug)]
 struct Guard {
@@ -46,55 +48,72 @@ fn parse_grid_and_start_pos(input: &str) -> (Grid<char>, Point) {
 fn get_guard_path_positions_assuming_no_loops(
     grid: &Grid<char>,
     start_pos: Point,
-) -> FxHashSet<Point> {
+) -> (FxHashSet<Point>, JumpTable) {
     let mut guard = Guard {
         position: start_pos,
         direction: UP,
     };
     let mut visited = FxHashSet::with_capacity_and_hasher(10_000, Default::default());
-    visited.insert(guard.position);
+    let mut jump_table = JumpTable::default();
+    let mut old_guard = guard.clone();
 
     while let Some(new_guard) = guard.turn(grid) {
+        if new_guard.direction != guard.direction {
+            jump_table.insert(old_guard, guard.clone());
+            old_guard = new_guard.clone();
+        }
         guard = new_guard;
         visited.insert(guard.position);
     }
-    visited
+    (visited, jump_table)
 }
 
 #[inline]
-fn does_start_pos_loop(grid: &Grid<char>, start_pos: Point) -> bool {
+fn has_loops(grid: &Grid<char>, start_pos: Point, jump_table: &JumpTable) -> bool {
+    // remove entries from jump_table that contain pos between key and value
     let mut guard = Guard {
         position: start_pos,
         direction: UP,
     };
+
     let mut visited = FxHashSet::with_capacity_and_hasher(10_000, Default::default());
     visited.insert(guard.clone());
 
-    while let Some(new_guard) = guard.turn(grid) {
+    while let Some(new_guard) = guard.turn(&grid) {
         guard = new_guard;
         if !visited.insert(guard.clone()) {
             return true;
         }
+        if let Some(next_guard) = jump_table.get(&guard) {
+            guard = next_guard.clone();
+        }
     }
     false
 }
 
 pub fn part_one(input: &str) -> Option<u32> {
     let (grid, start_pos) = parse_grid_and_start_pos(input);
-    let visited = get_guard_path_positions_assuming_no_loops(&grid, start_pos);
+    let (visited, _) = get_guard_path_positions_assuming_no_loops(&grid, start_pos);
     Some(visited.len() as u32)
 }
 
 pub fn part_two(input: &str) -> Option<u32> {
     let (grid, start_pos) = parse_grid_and_start_pos(input);
-    let positions_to_check = get_guard_path_positions_assuming_no_loops(&grid, start_pos);
+    let (visited, jump_table) = get_guard_path_positions_assuming_no_loops(&grid, start_pos);
 
-    let count = positions_to_check
+    let count = visited
         .par_iter()
         .filter(|&&pos| {
             let mut grid = grid.clone();
+            let jump_table: JumpTable = JumpTable::from_iter(
+                jump_table
+                    .iter()
+                    .filter(|(key, val)| !pos.is_between_inclusive(&key.position, &val.position))
+                    .map(|(key, val)| (key.clone(), val.clone())),
+            );
             grid[pos] = 'O';
-            does_start_pos_loop(&grid, start_pos)
+
+            has_loops(&grid, pos, &jump_table)
         })
         .count();