Optimize naive solution in 2025 day 12

Stop early based on similar sanity check heuristic.
Also deduplicate orientations.

Author: sim642

src/main/scala/eu/sim642/adventofcode2025/Day12.scala

@@ -23,89 +23,63 @@ object Day12 {
   }
 
   object NaiveSolution extends Solution {
-    /*def fits(shapes: Seq[Shape])(region: Region): Boolean = {
-
-    def helper(grid: Grid[Boolean], shapeCounts: Seq[Int]): Boolean = {
-      val shapeI = shapeCounts.indexWhere(_ > 0)
-      if (shapeI < 0)
-        true // nothing more to fit
-      else {
-        val newShapeCounts = shapeCounts.updated(shapeI, shapeCounts(shapeI) - 1)
-        val shape = shapes(shapeI)
-        (for {
-          shapeOrientation <- shape.orientations.iterator
-          shapeOrientationSize = Pos(shapeOrientation(0).size, shapeOrientation.size)
-          shapeOrientationBox = Box(Pos.zero, region.size - shapeOrientationSize)
-          shapeOrientationBox2 = Box(Pos.zero, shapeOrientationSize - Pos(1, 1))
-          pos <- shapeOrientationBox.iterator
-          if shapeOrientationBox2.iterator.forall(p => !(shapeOrientation(p) && grid(pos + p)))
-          newGrid = shapeOrientationBox2.iterator.foldLeft(grid)((newGrid, p) => newGrid.updatedGrid(pos + p, true))
-        } yield helper(newGrid, newShapeCounts)).exists(identity)
-      }
-    }
-
-    val initialGrid = Vector.fill(region.size.y, region.size.x)(false)
-    helper(initialGrid, region.shapeCounts)
-  }*/
-
-    // probably broken: skips over poss when finding place for a shape
     override def fits(shapes: Seq[Shape])(region: Region): Boolean = {
       val shapeOrientationBox = Box(Pos.zero, region.size - Pos(3, 3)) // assuming all shappes of same size
 
-      def helper(grid: Grid[Boolean], shapeCounts: Seq[Int], poss: List[Pos]): Boolean = {
+      val shapeOrientations = shapes.map(_.orientations.toSet)
+
+      def helper(grid: Grid[Boolean], shapeCounts: Seq[Int], poss: List[Pos], depth: Int): Boolean = {
+        val indent = " " * depth
+        //println(s"$indent: $shapeCounts")
+        //for (row <- grid) {
+        //  print(indent)
+        //  for (cell <- row)
+        //    print(if (cell) '#' else '.')
+        //  println()
+        //}
         val shapeI = shapeCounts.indexWhere(_ > 0)
         if (shapeI < 0)
           true // nothing more to fit
         else {
-          val newShapeCounts = shapeCounts.updated(shapeI, shapeCounts(shapeI) - 1)
-          val shape = shapes(shapeI)
-          (for {
-            shapeOrientation <- shape.orientations.iterator
-            shapeOrientationSize = Pos(shapeOrientation(0).size, shapeOrientation.size)
-            shapeOrientationBox2 = Box(Pos.zero, shapeOrientationSize - Pos(1, 1))
-            case pos :: newPoss <- poss.tails
-            if shapeOrientationBox2.iterator.forall(p => !(shapeOrientation(p) && grid(pos + p)))
-            newGrid = shapeOrientationBox2.iterator.foldLeft(grid)((newGrid, p) => newGrid.updatedGrid(pos + p, shapeOrientation(p)))
-          } yield helper(newGrid, newShapeCounts, newPoss)).exists(identity)
+          //val newShapeCounts = shapeCounts.updated(shapeI, shapeCounts(shapeI) - 1)
+          //val shape = shapes(shapeI)
+          if (poss.isEmpty)
+            false
+          else {
+            val pos = poss.head
+            //print(s"$indent $pos")
+            val todo = region.size.x * region.size.y - pos.x * region.size.y - pos.y
+            val areaLowerBound = // only counting the #-s in shapes
+              shapes
+                .map(_.countGrid(identity))
+                .lazyZip(shapeCounts)
+                .map(_ * _)
+                .sum
+            if (areaLowerBound > todo) {
+              //println("bounded")
+              false
+            } else {
+              //println()
+              val newPoss = poss.tail
+              (for {
+                ((shapeO, count), shapeI) <- shapeOrientations.lazyZip(shapeCounts).zipWithIndex
+                if count > 0
+                newShapeCounts = shapeCounts.updated(shapeI, count - 1)
+                shapeOrientation <- shapeO.iterator
+                shapeOrientationSize = Pos(shapeOrientation(0).size, shapeOrientation.size)
+                shapeOrientationBox2 = Box(Pos.zero, shapeOrientationSize - Pos(1, 1))
+                if shapeOrientationBox2.iterator.forall(p => !(shapeOrientation(p) && grid(pos + p)))
+                newGrid = shapeOrientationBox2.iterator.foldLeft(grid)((newGrid, p) => newGrid.updatedGrid(pos + p, newGrid(pos + p) || shapeOrientation(p)))
+              } yield helper(newGrid, newShapeCounts, newPoss, depth + 1)).exists(identity) ||
+                !Box(Pos.zero, Pos(2, 2)).iterator.forall(p => !grid(pos + p)) && helper(grid, shapeCounts, newPoss, depth + 1) // or don't place anything here
+            }
+          }
         }
       }
 
       val initialGrid = Vector.fill(region.size.y, region.size.x)(false)
-      helper(initialGrid, region.shapeCounts, shapeOrientationBox.iterator.toList)
-    }
-
-    /*def fits(shapes: Seq[Shape])(region: Region): Boolean = {
-    val shapeOrientationBox = Box(Pos.zero, region.size - Pos(3, 3)) // assuming all shappes of same size
-
-    def helper(grid: Grid[Boolean], shapeCounts: Seq[Int], poss: List[Pos]): Boolean = {
-      val shapeI = shapeCounts.indexWhere(_ > 0)
-      if (shapeI < 0)
-        true // nothing more to fit
-      else {
-        //val newShapeCounts = shapeCounts.updated(shapeI, shapeCounts(shapeI) - 1)
-        //val shape = shapes(shapeI)
-        if (poss.isEmpty)
-          false
-        else {
-          val pos = poss.head
-          val newPoss = poss.tail
-          (for {
-            ((shape, count), shapeI) <- shapes.lazyZip(shapeCounts).zipWithIndex
-            if count > 0
-            newShapeCounts = shapeCounts.updated(shapeI, count - 1)
-            shapeOrientation <- shape.orientations.iterator
-            shapeOrientationSize = Pos(shapeOrientation(0).size, shapeOrientation.size)
-            shapeOrientationBox2 = Box(Pos.zero, shapeOrientationSize - Pos(1, 1))
-            if shapeOrientationBox2.iterator.forall(p => !(shapeOrientation(p) && grid(pos + p)))
-            newGrid = shapeOrientationBox2.iterator.foldLeft(grid)((newGrid, p) => newGrid.updatedGrid(pos + p, shapeOrientation(p)))
-          } yield helper(newGrid, newShapeCounts, newPoss)).exists(identity) || helper(grid, shapeCounts, newPoss) // or don't place anything here
-        }
-      }
+      helper(initialGrid, region.shapeCounts, shapeOrientationBox.iterator.toList, 0)
     }
-
-    val initialGrid = Vector.fill(region.size.y, region.size.x)(false)
-    helper(initialGrid, region.shapeCounts, shapeOrientationBox.iterator.toList)
-  }*/
   }
 
   object SanitySolution extends Solution {

src/test/scala/eu/sim642/adventofcode2025/Day12Test.scala

@@ -40,12 +40,12 @@ class Day12Test extends AnyFunSuite {
       |12x5: 1 0 1 0 2 2
       |12x5: 1 0 1 0 3 2""".stripMargin
 
-  ignore("Part 1 examples") { // TODO: optimize
+  test("Part 1 examples") {
     import NaiveSolution._ // doesn't work with cheat solution
-    //val input1 = parseInput(exampleInput)
-    //assert(fits(input1.shapes)(input1.regions(0)))
-    //assert(fits(input1.shapes)(input1.regions(1)))
-    //assert(!fits(input1.shapes)(input1.regions(2)))
+    val input1 = parseInput(exampleInput)
+    assert(fits(input1.shapes)(input1.regions(0)))
+    assert(fits(input1.shapes)(input1.regions(1)))
+    assert(!fits(input1.shapes)(input1.regions(2)))
     assert(countFits(parseInput(exampleInput)) == 2)
   }