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) | 310 |
 
 ## 2023
 

src/year2024/day12.rs

@@ -1,120 +1,120 @@
 //! # Garden Groups
+//!
+//! Solves both parts simultaneously by flood filling each region.
+//!
+//! For part one we increment the perimeter for each neighbouring plot out of bounds
+//! or a different kind of plant.
+//!
+//! For part two we count 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. To speed things up these are
+//! precomputed and cached in a lookup table.
 use crate::util::grid::*;
-use crate::util::hash::*;
 use crate::util::point::*;
-use std::collections::VecDeque;
+use std::array::from_fn;
 
-const CLOCKWISE: [Point; 5] = [UP, RIGHT, DOWN, LEFT, UP];
+type Input = (usize, usize);
 
-pub fn parse(input: &str) -> Grid<u8> {
-    Grid::parse(input)
-}
+pub fn parse(input: &str) -> Input {
+    let grid = Grid::parse(input);
+    let lut = sides_lut();
+
+    let mut region = Vec::new();
+    let mut seen = grid.same_size_with(-1);
 
-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;
+    let mut part_one = 0;
+    let mut part_two = 0;
 
     for y in 0..grid.height {
         for x in 0..grid.width {
+            // Skip already filled points.
             let point = Point::new(x, y);
-            if seen[point] {
+            if seen[point] != -1 {
                 continue;
             }
 
+            // Assign a unique id to each region based on the first point that we encounter.
             let kind = grid[point];
+            let id = y * grid.width + x;
+
+            // Flood fill.
             let mut area = 0;
-            let mut perm = 0;
+            let mut perimeter = 0;
 
-            todo.push_back(point);
-            seen[point] = true;
+            region.push(point);
+            seen[point] = id;
 
-            while let Some(point) = todo.pop_front() {
+            while area < region.len() {
+                let point = region[area];
                 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;
+                        if seen[next] == -1 {
+                            region.push(next);
+                            seen[next] = id;
                         }
+                    } else {
+                        perimeter += 1;
                     }
                 }
             }
 
-            result += area * perm;
+            // Sum sides for all plots in the region.
+            let sides: usize = region
+                .drain(..)
+                .map(|point| {
+                    let index = DIAGONAL.iter().fold(0, |acc, &d| {
+                        (acc << 1) | (seen.contains(point + d) && seen[point + d] == id) as usize
+                    });
+                    lut[index]
+                })
+                .sum();
+
+            part_one += area * perimeter;
+            part_two += area * sides;
         }
     }
 
-    result
+    (part_one, part_two)
 }
 
-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();
-    let mut result = 0;
-
-    for y in 0..grid.height {
-        for x in 0..grid.width {
-            let point = Point::new(x, y);
-            if seen[point] {
-                continue;
-            }
-
-            let kind = grid[point];
-            let mut size = 0;
-            let mut sides = 0;
-
-            todo.push_back(point);
-            seen[point] = true;
-
-            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;
-
-                for next in ORTHOGONAL.map(|o| point + o) {
-                    if grid.contains(next) && grid[next] == kind && !seen[next] {
-                        seen[next] = true;
-                        todo.push_back(next);
-                    }
-                }
-            }
+pub fn part1(input: &Input) -> usize {
+    input.0
+}
 
-            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();
+pub fn part2(input: &Input) -> usize {
+    input.1
+}
 
-                if count == 1 {
-                    sides += 1;
-                } else if count == 4 {
-                    sides += 2;
-                }
-            }
+/// 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);
 
-            corner.clear();
-            middle.clear();
-            result += size * sides;
-        }
-    }
+        let ul = !(up || left) || (up && left && !up_left);
+        let ur = !(up || right) || (up && right && !up_right);
+        let dl = !(down || left) || (down && left && !down_left);
+        let dr = !(down || right) || (down && right && !down_right);
 
-    result
+        (ul as usize) + (ur as usize) + (dl as usize) + (dr as usize)
+    })
 }