Faster simpler approach

Author: maneatingape

README.md

@@ -83,7 +83,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 9 | [Disk Fragmenter](https://adventofcode.com/2024/day/9) | [Source](src/year2024/day09.rs) | 106 |
 | 10 | [Hoof It](https://adventofcode.com/2024/day/10) | [Source](src/year2024/day10.rs) | 38 |
 | 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) | 1582 |
+| 12 | [Garden Groups](https://adventofcode.com/2024/day/12) | [Source](src/year2024/day12.rs) | 526 |
 
 ## 2023
 

src/year2024/day12.rs

@@ -1,19 +1,40 @@
 //! # Garden Groups
+//!
+//! Part one flood fills each region, adding 4 to the perimeter for each plot
+//! then subtracting 2 for each neighbour that we've already added.
+//!
+//! Part two counts corners, as the number of corners equals the number of sides.
+//! We remove a corner when another plot is adjacent either up, down, left or right:
+//!
+//! ```none
+//!     .#.    ...
+//!     .#.    ##.
+//!     ...    ...
+//! ```
+//!
+//! We add back a corner when it's concave, for example where a plot is above, right but
+//! not above and to the right:
+//!
+//! ```none
+//!     .#.
+//!     .##
+//!     ...
+//! ```
+//!
+//! There are 8 neighbours to check, giving 2⁸ possibilities. These are precomputed and cached
+//! in a lookup table.
 use crate::util::grid::*;
-use crate::util::hash::*;
 use crate::util::point::*;
+use std::array::from_fn;
 use std::collections::VecDeque;
 
-const CLOCKWISE: [Point; 5] = [UP, RIGHT, DOWN, LEFT, UP];
-
 pub fn parse(input: &str) -> Grid<u8> {
     Grid::parse(input)
 }
 
 pub fn part1(grid: &Grid<u8>) -> i32 {
     let mut todo = VecDeque::new();
     let mut seen = grid.same_size_with(false);
-    let mut added = grid.same_size_with(false);
     let mut result = 0;
 
     for y in 0..grid.height {
@@ -23,98 +44,104 @@ pub fn part1(grid: &Grid<u8>) -> i32 {
                 continue;
             }
 
+            // Flood fill each region.
             let kind = grid[point];
             let mut area = 0;
-            let mut perm = 0;
+            let mut perimeter = 0;
 
             todo.push_back(point);
             seen[point] = true;
 
             while let Some(point) = todo.pop_front() {
                 area += 1;
-                perm += 4;
-                added[point] = true;
 
                 for next in ORTHOGONAL.map(|o| point + o) {
                     if grid.contains(next) && grid[next] == kind {
                         if !seen[next] {
                             seen[next] = true;
                             todo.push_back(next);
                         }
-                        if added[next] {
-                            perm -= 2;
-                        }
+                    } else {
+                        perimeter += 1;
                     }
                 }
             }
 
-            result += area * perm;
+            result += area * perimeter;
         }
     }
 
     result
 }
 
-pub fn part2(grid: &Grid<u8>) -> u32 {
-    let mut seen = grid.same_size_with(false);
-    let mut todo = VecDeque::new();
-    let mut corner = FastMap::new();
-    let mut middle = FastMap::new();
+pub fn part2(grid: &Grid<u8>) -> usize {
+    // Lookup table that returns number of corners for all combinations of neighbours.
+    let lut = sides_lut();
+
     let mut result = 0;
+    let mut todo = VecDeque::new();
+    let mut seen = grid.same_size_with(-1);
+    let mut region = Vec::new();
 
     for y in 0..grid.height {
         for x in 0..grid.width {
             let point = Point::new(x, y);
-            if seen[point] {
+            if seen[point] != -1 {
                 continue;
             }
 
             let kind = grid[point];
-            let mut size = 0;
-            let mut sides = 0;
+            let id = y * grid.width + x;
 
             todo.push_back(point);
-            seen[point] = true;
+            seen[point] = id;
 
             while let Some(point) = todo.pop_front() {
-                size += 1;
-                let x = 2 * point.x;
-                let y = 2 * point.y;
-
-                *corner.entry(Point::new(x, y)).or_insert(0) += 1;
-                *corner.entry(Point::new(x + 2, y)).or_insert(0) += 1;
-                *corner.entry(Point::new(x, y + 2)).or_insert(0) += 1;
-                *corner.entry(Point::new(x + 2, y + 2)).or_insert(0) += 1;
-
-                *middle.entry(Point::new(x + 1, y)).or_insert(0) += 1;
-                *middle.entry(Point::new(x, y + 1)).or_insert(0) += 1;
-                *middle.entry(Point::new(x + 2, y + 1)).or_insert(0) += 1;
-                *middle.entry(Point::new(x + 1, y + 2)).or_insert(0) += 1;
+                region.push(point);
 
                 for next in ORTHOGONAL.map(|o| point + o) {
-                    if grid.contains(next) && grid[next] == kind && !seen[next] {
-                        seen[next] = true;
+                    if grid.contains(next) && grid[next] == kind && seen[next] == -1 {
+                        seen[next] = id;
                         todo.push_back(next);
                     }
                 }
             }
 
-            for (&point, _) in corner.iter().filter(|(_, &v)| v < 4) {
-                let freq = CLOCKWISE.map(|c| *middle.get(&(point + c)).unwrap_or(&2));
-                let count = freq.windows(2).filter(|w| w[0] < 2 && w[1] < 2).count();
+            let size = region.len();
 
-                if count == 1 {
-                    sides += 1;
-                } else if count == 4 {
-                    sides += 2;
-                }
+            for point in region.drain(..) {
+                let index = DIAGONAL.iter().fold(0, |acc, &d| {
+                    (acc << 1) | (seen.contains(point + d) && seen[point + d] == id) as usize
+                });
+                result += size * lut[index];
             }
-
-            corner.clear();
-            middle.clear();
-            result += size * sides;
         }
     }
 
     result
 }
+
+/// There are 8 neighbours to check, giving 2⁸ possibilities. Precompute the number of corners
+/// once into a lookup table to speed things up.
+fn sides_lut() -> [usize; 256] {
+    from_fn(|neighbours| {
+        let [up_left, up, up_right, left, right, down_left, down, down_right] =
+            from_fn(|i| neighbours & (1 << i) != 0);
+        let mut sides = 0;
+
+        if !(up || left) || (up && left && !up_left) {
+            sides += 1;
+        }
+        if !(up || right) || (up && right && !up_right) {
+            sides += 1;
+        }
+        if !(down || left) || (down && left && !down_left) {
+            sides += 1;
+        }
+        if !(down || right) || (down && right && !down_right) {
+            sides += 1;
+        }
+
+        sides
+    })
+}