Solution 2018-11, part 2 (Chronal Charge)

Idea: Use a cache for already calculated smaller squares and
      add the sums of the remaining row and column.

... but it still does take too much time.

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year2018/day11/ChronalCharge.kt

@@ -5,7 +5,7 @@ import de.ronny_h.aoc.extensions.grids.Coordinates
 import de.ronny_h.aoc.extensions.grids.Grid
 import de.ronny_h.aoc.extensions.numbers.digit
 
-fun main() = ChronalCharge().run("34,13", "")
+fun main() = ChronalCharge().run("34,13", "280,218,11")
 
 class ChronalCharge : AdventOfCode<String>(2018, 11) {
     // start:  11:59
@@ -17,41 +17,65 @@ class ChronalCharge : AdventOfCode<String>(2018, 11) {
 }
 
 class PowerCellGrid(serialNumber: Int) : Grid<Int>(300, 300, -1000) {
+    private val cache = mutableMapOf<Configuration, Int>()
+
     init {
         forEachIndex { y, x ->
             val rackId = x + 10
             var powerLevel = rackId * y + serialNumber
             powerLevel *= rackId
             val hundredsDigit = powerLevel.digit(3)
             this[y, x] = hundredsDigit - 5
+            cache[Configuration(Coordinates(y, x), 1)] = this[y, x]
         }.last()
     }
 
     fun findSquareWithLargestTotal(): String {
         val max = (1..300)
-            .map { findSquareWithLargestTotalForSize(it) }
+            .map {
+                println("calc for square size $it")
+                findSquareWithLargestTotalForSize(it)
+            }
             .maxBy { it.total }
+            .configuration
         return "${max.coordinates.col},${max.coordinates.row},${max.size}"  // X,Y,size
     }
 
     fun find3x3SquareWithLargestTotal(): String {
-        val maxCoordinates = findSquareWithLargestTotalForSize(3).coordinates
+        val maxCoordinates = findSquareWithLargestTotalForSize(3).configuration.coordinates
         return "${maxCoordinates.col},${maxCoordinates.row}"  // X,Y
     }
 
-    private data class Square(val coordinates: Coordinates, val size: Int, val total: Int)
+    private data class Configuration(val coordinates: Coordinates, val size: Int)
+    private data class Square(val configuration: Configuration, val total: Int)
 
     private fun findSquareWithLargestTotalForSize(squareSize: Int): Square =
         forEachCoordinates { coordinates, _ ->
-            val total = (0..<squareSize).sumOf { i ->
-                (0..<squareSize).sumOf { j ->
-                    this[coordinates.row + i, coordinates.col + j]
-                }
+            val config = Configuration(coordinates, squareSize)
+            val total = if (squareSize == 1) {
+                cache.getValue(config)
+            } else {
+                val smallerCached = cache[Configuration(coordinates, squareSize - 1)]
+
+                val total = smallerCached?.let { cached ->
+                    val additionalColumnTotal =
+                        (0..<squareSize).sumOf { this[coordinates.row + it, coordinates.col + squareSize - 1] }
+                    val additionalRowTotal =
+                        (0..<squareSize - 1).sumOf { this[coordinates.row + squareSize - 1, coordinates.col + it] }
+                    cached + additionalColumnTotal + additionalRowTotal
+                } ?: sumOfSquare(coordinates, squareSize)
+                cache[config] = total
+                total
             }
-            Square(coordinates, squareSize, total)
+            Square(config, total)
         }
             .maxBy { it.total }
 
+    private fun sumOfSquare(coordinates: Coordinates, squareSize: Int): Int = (0..<squareSize).sumOf { i ->
+        (0..<squareSize).sumOf { j ->
+            this[coordinates.row + i, coordinates.col + j]
+        }
+    }
 
     override fun Char.toElementType(): Int = digitToInt()
 }