day 12 part 2, all thanks to other people on the internet

Author: K20shores

2024/include/aoc/2024/pos.h

@@ -65,4 +65,13 @@ Pos down = {.x = 0, .y = 1};
 Pos left = {.x = -1, .y = 0};
 Pos right = {.x = 1, .y = 0};
 
+Pos N = up;
+Pos S = down;
+Pos E = right;
+Pos W = left;
+Pos NE = up + right;
+Pos NW = up + left;
+Pos SE = down + right;
+Pos SW = down + left;
+
 std::vector<Pos> directions = {up, down, left, right};

2024/src/day12.cpp

@@ -10,35 +10,31 @@
 #include <set>
 #include <queue>
 
-struct Data {
+struct Data
+{
   std::vector<std::string> gardens;
 };
 
-struct Node {
-  Node* up;
-  Node* down;
-  Node* left;
-  Node* right;
-  char value;
+bool in_bounds(const Data &data, const Pos &p)
+{
+  return p.x >= 0 && p.y >= 0 && p.x < data.gardens[0].size() && p.y < data.gardens.size();
 };
 
 int part1(const Data &data)
 {
   std::set<Pos> unvisited;
   std::map<char, std::vector<std::pair<int, int>>> dimensions;
 
-  for(size_t j = 0; j < data.gardens.size(); ++j) {
-    for(size_t i = 0; i < data.gardens[0].size(); ++i) {
+  for (size_t j = 0; j < data.gardens.size(); ++j)
+  {
+    for (size_t i = 0; i < data.gardens[0].size(); ++i)
+    {
       unvisited.insert({.x = i, .y = j});
     }
   }
 
-  auto in_bounds = [&](const Pos& p) {
-    return p.x >= 0 && p.y >= 0 && p.x < data.gardens[0].size() && p.y < data.gardens.size();
-  };
-
-
-  while (unvisited.size() > 0) {
+  while (unvisited.size() > 0)
+  {
     Pos p = *unvisited.begin();
     std::queue<Pos> q;
 
@@ -48,30 +44,39 @@ int part1(const Data &data)
     q.push(p);
 
     // floodfill
-    while(!q.empty()) {
+    while (!q.empty())
+    {
       Pos cur = q.front();
-      if (unvisited.contains(cur)) {
+      if (unvisited.contains(cur))
+      {
         unvisited.erase(cur);
         ++area;
-        for(auto dir: directions) {
+        for (auto dir : directions)
+        {
           Pos next = cur + dir;
-          if (in_bounds(next)) {
+          if (in_bounds(data, next))
+          {
             char next_char = data.gardens[next.y][next.x];
-            if (next_char == target) {
-              if (unvisited.contains(next)) {
+            if (next_char == target)
+            {
+              if (unvisited.contains(next))
+              {
                 q.push(next);
               }
             }
-            else {
+            else
+            {
               ++perimeter;
             }
           }
-          else {
+          else
+          {
             ++perimeter;
           }
         }
       }
-      else {
+      else
+      {
         // we've been here before
         // but this node was added into the queue by another node
       }
@@ -82,19 +87,119 @@ int part1(const Data &data)
   }
 
   int sum = 0;
-  for(auto& [key, val] : dimensions) {
-    for(auto& [area, perimeter]: val) {
+  for (auto &[key, val] : dimensions)
+  {
+    for (auto &[area, perimeter] : val)
+    {
       sum += area * perimeter;
-      std::cout << std::format("{}: area {}, perimeter: {}\n", key, area, perimeter);
     }
   }
 
   return sum;
 }
 
+int count_corners(const Data &data, Pos cur)
+{
+  int cornes = 0;
+  auto same = [&](Pos next){ return (in_bounds(data, next) && data.gardens[cur.y][cur.x] == data.gardens[next.y][next.x]);};
+
+  bool n = same(cur+N);
+  bool ne = same(cur+NE);
+  bool e = same(cur+E);
+  bool se = same(cur+SE);
+  bool s = same(cur+S);
+  bool sw = same(cur+SW);
+  bool w = same(cur+W);
+  bool nw = same(cur+NW);
+
+  // convex corners, or an L shaped region where the current characters
+  // AX XA  A  A
+  //  A A  AX  AX 
+  // concave corners, or when a cell is the same as its two orthongal neighbors but not the same
+  // as its diagonal neighboer
+  // AA AA AX XA
+  // XA XA AA AA
+
+  // the left side of the || operator checks convex corners
+  // the right side of the || operators chekcs concave corners
+  if (!n && !e || n && e && !ne) cornes += 1;
+  if (!e && !s || e && s && !se) cornes += 1;
+  if (!s && !w || s && w && !sw) cornes += 1;
+  if (!w && !n || w && n && !nw) cornes += 1;
+
+  return cornes;
+}
+
 int part2(const Data &data)
 {
-  return 0;
+  std::set<Pos> unvisited;
+  std::map<char, std::vector<std::pair<int, int>>> dimensions;
+
+  for (size_t j = 0; j < data.gardens.size(); ++j)
+  {
+    for (size_t i = 0; i < data.gardens[0].size(); ++i)
+    {
+      unvisited.insert({.x = i, .y = j});
+    }
+  }
+
+  while (unvisited.size() > 0)
+  {
+    Pos p = *unvisited.begin();
+    std::queue<Pos> q;
+
+    char target = data.gardens[p.y][p.x];
+    int area = 0;
+    int sides = 0;
+    q.push(p);
+
+    // floodfill
+    while (!q.empty())
+    {
+      Pos cur = q.front();
+      if (unvisited.contains(cur))
+      {
+        unvisited.erase(cur);
+        ++area;
+        sides += count_corners(data, cur);
+        for (auto dir : directions)
+        {
+          Pos next = cur + dir;
+          if (in_bounds(data, next))
+          {
+            char next_char = data.gardens[next.y][next.x];
+            if (next_char == target)
+            {
+              if (unvisited.contains(next))
+              {
+                q.push(next);
+              }
+            }
+          }
+        }
+      }
+      else
+      {
+        // we've been here before
+        // but this node was added into the queue by another node
+      }
+      q.pop();
+    }
+
+    dimensions[target].push_back({area, sides});
+  }
+
+  int sum = 0;
+  for (auto &[key, val] : dimensions)
+  {
+    for (auto &[area, sides] : val)
+    {
+      sum += area * sides;
+      std::cout << std::format("{}: area {}, sides: {}\n", key, area, sides);
+    }
+  }
+
+  return sum;
 }
 
 Data parse()
@@ -155,15 +260,17 @@ int main(int argc, char **argv)
 
   auto first = part1(data);
   std::cout << "Part 1: " << first << std::endl;
-  
+
   auto second = part2(data);
   std::cout << "Part 2: " << second << std::endl;
 
   first != answer1 ? throw std::runtime_error("Part 1 incorrect") : nullptr;
   second != answer2 ? throw std::runtime_error("Part 2 incorrect") : nullptr;
 
-  for (int i = 1; i < argc; ++i) {
-    if (std::string(argv[i]) == "--benchmark") {
+  for (int i = 1; i < argc; ++i)
+  {
+    if (std::string(argv[i]) == "--benchmark")
+    {
       benchmark::Initialize(&argc, argv);
       benchmark::RunSpecifiedBenchmarks();
       return 0;