Faster approach seaching for the bounding box

Author: maneatingape

README.md

@@ -85,7 +85,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 11 | [Plutonian Pebbles](https://adventofcode.com/2024/day/11) | [Source](src/year2024/day11.rs) | 248 |
 | 12 | [Garden Groups](https://adventofcode.com/2024/day/12) | [Source](src/year2024/day12.rs) | 289 |
 | 13 | [Claw Contraption](https://adventofcode.com/2024/day/13) | [Source](src/year2024/day13.rs) | 14 |
-| 14 | [Restroom Redoubt](https://adventofcode.com/2024/day/14) | [Source](src/year2024/day14.rs) | 456 |
+| 14 | [Restroom Redoubt](https://adventofcode.com/2024/day/14) | [Source](src/year2024/day14.rs) | 104 |
 
 ## 2023
 

src/year2024/day14.rs

@@ -4,11 +4,18 @@
 //! The image appears in part two when the positions of all robots are unique.
 //!
 //! The x coordinates repeat every 101 seconds and the y coordinates repeat every 103 seconds.
-//! Calculating each axis independently then looking it up is twice as fast
-//! as calculating as needed.
+//! First we check for times when the robot x coordinates could form the left and right columns
+//! of the tree's bounding box. This gives a time `t` mod 101.
+//!
+//! Then we check the y coordinates looking for the top and bottom rows of the bounding box,
+//! giving a time `u` mod 103.
+//!
+//! Using the [Chinese Remainder Theorem](https://en.wikipedia.org/wiki/Chinese_remainder_theorem)
+//! we combine the two times into a single time mod 10403 that is the answer.
+use crate::util::grid::*;
 use crate::util::iter::*;
-use crate::util::math::*;
 use crate::util::parse::*;
+use crate::util::point::*;
 
 type Robot = [i32; 4];
 
@@ -47,52 +54,69 @@ pub fn part1(input: &[Robot]) -> i32 {
     q1 * q2 * q3 * q4
 }
 
-pub fn part2(input: &[Robot]) -> usize {
-    let robots: Vec<_> = input
-        .iter()
-        .map(|&[x, y, h, v]| [x, y, h.rem_euclid(101), v.rem_euclid(103)])
-        .collect();
+pub fn part2(robots: &[Robot]) -> i32 {
+    // Search for times mod 101 when the tree could possibly exist using x coordinates only.
+    let mut columns = Vec::new();
 
-    let coefficient1 = 103 * 103.mod_inv(101).unwrap();
-    let coefficient2 = 101 * 101.mod_inv(103).unwrap();
-    let horizontal: Vec<_> = (0..101).map(|n| n.mod_inv(101)).collect();
-    let vertical: Vec<_> = (0..103).map(|n| n.mod_inv(103)).collect();
+    for time in 0..101 {
+        let mut xs = [0; 101];
 
-    let mut unique = vec![true; 10403];
+        for [x, _, dx, _] in robots {
+            let index = (x + dx * time).rem_euclid(101);
+            xs[index as usize] += 1;
+        }
 
-    for (i, &[x1, y1, h1, v1]) in robots.iter().enumerate().skip(1) {
-        for &[x2, y2, h2, v2] in robots.iter().take(i) {
-            if x1 == x2 && h1 == h2 {
-                if let Some(b) = vertical[to_index(v2 - v1, 103)] {
-                    let u = to_index((y1 - y2) * b, 103);
+        // Tree bounding box columns are 33 high.
+        if xs.iter().filter(|&&c| c >= 33).count() >= 2 {
+            columns.push(time);
+        }
+    }
 
-                    for n in (0..10403).step_by(103) {
-                        unique[n + u] = false;
-                    }
-                }
-            } else if y1 == y2 && v1 == v2 {
-                if let Some(a) = horizontal[to_index(h2 - h1, 101)] {
-                    let t = to_index((x1 - x2) * a, 101);
+    // Search for times mod 103 when the tree could possibly exist using y coordinates only.
+    let mut rows = Vec::new();
 
-                    for n in (0..10403).step_by(101) {
-                        unique[n + t] = false;
-                    }
-                }
-            } else if let Some(a) = horizontal[to_index(h2 - h1, 101)] {
-                if let Some(b) = vertical[to_index(v2 - v1, 103)] {
-                    let t = (x1 - x2) * a;
-                    let u = (y1 - y2) * b;
-                    let crt = to_index(t * coefficient1 + u * coefficient2, 10403);
-                    unique[crt] = false;
+    for time in 0..103 {
+        let mut ys = [0; 103];
+
+        for [_, y, _, dy] in robots {
+            let index = (y + dy * time).rem_euclid(103);
+            ys[index as usize] += 1;
+        }
+
+        if ys.iter().filter(|&&c| c >= 31).count() >= 2 {
+            rows.push(time);
+        }
+    }
+
+    // If there's only one combination then return answer.
+    if rows.len() == 1 && columns.len() == 1 {
+        let t = columns[0];
+        let u = rows[0];
+        // Combine indices using the Chinese Remainder Theorem to get index mod 10403.
+        return (5253 * t + 5151 * u) % 10403;
+    }
+
+    // Backup check for time when all robot positions are unique.
+    let mut grid = Grid::new(101, 103, 0);
+
+    for &t in &columns {
+        'outer: for &u in &rows {
+            let time = (5253 * t + 5151 * u) % 10403;
+
+            for &[x, y, dx, dy] in robots {
+                let x = (x + dx * time).rem_euclid(101);
+                let y = (y + dy * time).rem_euclid(103);
+
+                let point = Point::new(x, y);
+                if grid[point] == time {
+                    continue 'outer;
                 }
+                grid[point] = time;
             }
+
+            return time;
         }
     }
 
-    unique.iter().position(|&u| u).unwrap()
-}
-
-#[inline]
-fn to_index(a: i32, m: i32) -> usize {
-    a.rem_euclid(m) as usize
+    unreachable!()
 }