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) | 310 |
+| 12 | [Garden Groups](https://adventofcode.com/2024/day/12) | [Source](src/year2024/day12.rs) | 289 |
 
 ## 2023
 

src/year2024/day12.rs

@@ -2,40 +2,31 @@
 //!
 //! 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 one we increment the perimeter for each neighbouring plot belonging to a different
+//! region or out of bounds.
 //!
-//! 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.
-//! For example, considering the top left corner of the plot:
+//! For part two we count each plot on the edge as either 0, 1 or 2 sides then divide by 2.
+//! An edge plot contributes nothing if it has 2 edge neighbours facing the same way,
+//! one if has a single neighbour and two if it has no neighbours.
 //!
-//! ```none
-//!     ..      .#      ..      ##
-//!     .# ✓    .# ✗    ## ✗    ## ✗
-//! ```
-//!
-//! However we add back a corner when it's concave, for example where a plot is above, left but
-//! not above and to the left:
+//! For example, considering the right edge:
 //!
 //! ```none
-//!     .#
-//!     ## ✓
+//!     ...        ...        .#. > 1
+//!     .#. > 2    .#. > 1    .#. > 0
+//!     ...        .#. > 1    .#. > 1
 //! ```
-//!
-//! 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::point::*;
-use std::array::from_fn;
 
 type Input = (usize, usize);
 
 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(0);
+    let mut todo = Vec::new();
+    let mut edge = Vec::new();
+    let mut seen = grid.same_size_with(false);
 
     let mut part_one = 0;
     let mut part_two = 0;
@@ -44,48 +35,54 @@ pub fn parse(input: &str) -> Input {
         for x in 0..grid.width {
             // Skip already filled points.
             let point = Point::new(x, y);
-            if seen[point] > 0 {
+            if seen[point] {
                 continue;
             }
 
-            // Assign a unique id to each region based on the first point that we encounter.
+            // Flood fill, using area as an index.
             let kind = grid[point];
-            let id = y * grid.width + x + 1;
+            let check = |point| grid.contains(point) && grid[point] == kind;
 
-            // Flood fill, using area as an index.
             let mut area = 0;
             let mut perimeter = 0;
             let mut sides = 0;
 
-            region.push(point);
-            seen[point] = id;
+            todo.push(point);
+            seen[point] = true;
 
-            while area < region.len() {
-                let point = region[area];
+            while area < todo.len() {
+                let point = todo[area];
                 area += 1;
 
-                for next in ORTHOGONAL.map(|o| point + o) {
-                    if grid.contains(next) && grid[next] == kind {
-                        if seen[next] == 0 {
-                            region.push(next);
-                            seen[next] = id;
+                for direction in ORTHOGONAL {
+                    let next = point + direction;
+
+                    if check(next) {
+                        if !seen[next] {
+                            todo.push(next);
+                            seen[next] = true;
                         }
                     } else {
+                        edge.push((point, direction));
                         perimeter += 1;
                     }
                 }
             }
 
             // Sum sides for all plots in the region.
-            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
-                });
-                sides += lut[index];
+            for &(p, d) in &edge {
+                let r = d.clockwise();
+                let l = d.counter_clockwise();
+
+                sides += (!check(p + l) || check(p + l + d)) as usize;
+                sides += (!check(p + r) || check(p + r + d)) as usize;
             }
 
+            todo.clear();
+            edge.clear();
+
             part_one += area * perimeter;
-            part_two += area * sides;
+            part_two += area * (sides / 2);
         }
     }
 
@@ -99,19 +96,3 @@ pub fn part1(input: &Input) -> usize {
 pub fn part2(input: &Input) -> usize {
     input.1
 }
-
-/// 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 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);
-
-        (ul as usize) + (ur as usize) + (dl as usize) + (dr as usize)
-    })
-}