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

src/year2024/day12.rs

@@ -1,20 +1,17 @@
 //! # Garden Groups
 use crate::util::grid::*;
-use crate::util::hash::*;
 use crate::util::point::*;
 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 result = 0;
     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 {
         for x in 0..grid.width {
@@ -56,11 +53,10 @@ pub fn part1(grid: &Grid<u8>) -> i32 {
 }
 
 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;
+    let mut todo = VecDeque::new();
+    let mut seen = grid.same_size_with(false);
+    let mut region = Vec::new();
 
     for y in 0..grid.height {
         for x in 0..grid.width {
@@ -70,6 +66,7 @@ pub fn part2(grid: &Grid<u8>) -> u32 {
             }
 
             let kind = grid[point];
+            let mut added = grid.same_size_with(false);
             let mut size = 0;
             let mut sides = 0;
 
@@ -78,18 +75,8 @@ pub fn part2(grid: &Grid<u8>) -> u32 {
 
             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;
+                added[point] = true;
+                region.push(point);
 
                 for next in ORTHOGONAL.map(|o| point + o) {
                     if grid.contains(next) && grid[next] == kind && !seen[next] {
@@ -99,19 +86,49 @@ pub fn part2(grid: &Grid<u8>) -> u32 {
                 }
             }
 
-            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 test = |point| added.contains(point) && added[point];
 
-                if count == 1 {
-                    sides += 1;
-                } else if count == 4 {
-                    sides += 2;
+            for point in region.drain(..) {
+                let mut ul = 1;
+                let mut ur = 1;
+                let mut dl = 1;
+                let mut dr = 1;
+
+                // Plots to the side that block off corners
+                if test(point + UP) {
+                    ul = 0;
+                    ur = 0;
+                }
+                if test(point + DOWN) {
+                    dl = 0;
+                    dr = 0;
+                }
+                if test(point + LEFT) {
+                    ul = 0;
+                    dl = 0;
+                }
+                if test(point + RIGHT) {
+                    ur = 0;
+                    dr = 0;
+                }
+
+                // Concave corners
+                if test(point + UP) && test(point + LEFT) && !test(point + UP + LEFT) {
+                    ul = 1;
+                }
+                if test(point + UP) && test(point + RIGHT) && !test(point + UP + RIGHT) {
+                    ur = 1;
+                }
+                if test(point + DOWN) && test(point + LEFT) && !test(point + DOWN + LEFT) {
+                    dl = 1;
                 }
+                if test(point + DOWN) && test(point + RIGHT) && !test(point + DOWN + RIGHT) {
+                    dr = 1;
+                }
+
+                sides += ul + ur + dl + dr;
             }
 
-            corner.clear();
-            middle.clear();
             result += size * sides;
         }
     }