Speed things up by caching slow GCD calculation

Author: maneatingape

README.md

@@ -244,7 +244,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 7 | [Amplification Circuit](https://adventofcode.com/2019/day/7) | [Source](src/year2019/day07.rs) | 79 |
 | 8 | [Space Image Format](https://adventofcode.com/2019/day/8) | [Source](src/year2019/day08.rs) | 4 |
 | 9 | [Sensor Boost](https://adventofcode.com/2019/day/9) | [Source](src/year2019/day09.rs) | 1008 |
-| 10 | [Monitoring Station](https://adventofcode.com/2019/day/10) | [Source](src/year2019/day10.rs) | 1092 |
+| 10 | [Monitoring Station](https://adventofcode.com/2019/day/10) | [Source](src/year2019/day10.rs) | 404 |
 | 11 | [Space Police](https://adventofcode.com/2019/day/11) | [Source](src/year2019/day11.rs) | 320 |
 | 12 | [The N-Body Problem](https://adventofcode.com/2019/day/12) | [Source](src/year2019/day12.rs) | 838 |
 | 13 | [Care Package](https://adventofcode.com/2019/day/13) | [Source](src/year2019/day13.rs) | 2527 |

src/year2019/day10.rs

@@ -46,49 +46,58 @@
 //! sorting a second time in this order.
 //!
 //! [`atan2`]: f64::atan2
+use crate::util::grid::*;
 use crate::util::math::*;
 use crate::util::point::*;
 use std::cmp::Ordering;
 
 type Input = (i32, i32);
 
 pub fn parse(input: &str) -> Input {
-    let raw: Vec<_> = input.lines().map(str::as_bytes).collect();
-    let width = raw[0].len() as i32;
-    let height = raw.len() as i32;
+    let grid = Grid::parse(input);
+    let width = grid.width;
+    let height = grid.height;
 
     // Convert asteroids to `Point` objects.
     let mut points = Vec::new();
 
-    for (y, row) in raw.iter().enumerate() {
-        for (x, &col) in row.iter().enumerate() {
-            if col == b'#' {
-                points.push(Point::new(x as i32, y as i32));
+    for y in 0..height {
+        for x in 0..width {
+            let point = Point::new(x, y);
+            if grid[point] == b'#' {
+                points.push(point);
             }
         }
     }
 
     // Find asteroid with the highest visibility.
+    let mut seen = Grid::new(2 * width, 2 * height, 0);
+    let mut cache = grid.same_size_with(0);
     let mut visible = vec![0; points.len()];
-    let mut seen = vec![0; (4 * width * height) as usize];
     let mut max_visible = 0;
     let mut max_index = 0;
 
     for i in 0..(points.len() - 1) {
         for j in (i + 1)..points.len() {
-            let mut delta = points[j] - points[i];
+            let delta = points[j] - points[i];
+            let key = Point::new(delta.x.abs(), delta.y.abs());
+
+            let gcd = if cache[key] > 0 {
+                cache[key]
+            } else {
+                cache[key] = key.x.gcd(key.y);
+                cache[key]
+            };
 
             // Key insight is that points on the same line are integer multiples of each other.
-            let factor = delta.x.gcd(delta.y).abs();
-            delta.x /= factor;
-            delta.y /= factor;
+            let adjusted = Point::new(delta.x / gcd, delta.y / gcd);
 
             // This works as the points are in order from left to right and top to bottom,
             // so we process points from nearest to furthest.
-            let index = (2 * width) * (height + delta.y) + (width + delta.x);
+            let index = Point::new(width + adjusted.x, height + adjusted.y);
 
-            if seen[index as usize] <= i {
-                seen[index as usize] = i + 1;
+            if seen[index] <= i {
+                seen[index] = i + 1;
                 visible[i] += 1;
                 visible[j] += 1;
             }