Day 18 with 'good enough' DFS

Author: cluddles

aoc-secret

@@ -23,6 +23,7 @@ fun main() {
         Day15,
         Day16,
         Day17,
+        Day18,
     )
 
     measureTime {

src/main/kotlin/com/cluddles/aoc/y2024/All2024.kt

@@ -21,7 +21,7 @@ object Day16: Solver<Grid<Char>, Int> {
         return CharGrid(src.lines().toList())
     }
 
-    /** Populate all cell [costs] with a simple flood fill */
+    /** Populate all cell [costs] with a simple depth first search (flood fill) */
     private fun populateCosts(costs: MutableGrid<Int>, input: Grid<Char>, x: Int, y: Int, dir: Dir4, cost: Int) {
         val bestCost = costs[x, y]
         if (bestCost >= 0 && bestCost < cost) return

src/main/kotlin/com/cluddles/aoc/y2024/Day16.kt

@@ -0,0 +1,67 @@
+package com.cluddles.aoc.y2024
+
+import com.cluddles.aoc.core.Harness
+import com.cluddles.aoc.core.Solver
+import com.cluddles.aoc.core.SolverInput
+import com.cluddles.aoc.util.Dir4
+import com.cluddles.aoc.util.Grid
+import com.cluddles.aoc.util.IntGrid
+import com.cluddles.aoc.util.MutableGrid
+
+/** RAM Run */
+object Day18: Solver<Grid<Int>, String> {
+
+    override fun prepareInput(src: SolverInput): Grid<Int> {
+        return prepareInput(src, 71, 71)
+    }
+
+    fun prepareInput(src: SolverInput, width: Int, height: Int): Grid<Int> {
+        val result = IntGrid(width, height, Int.MAX_VALUE)
+        for (l in src.lines().withIndex()) {
+            val (x, y) = l.value.split(",").map { it.toInt() }
+            result[x, y] = l.index
+        }
+        return result
+    }
+
+    // Quick and dirty DFS
+    private fun populateCosts(input: Grid<Int>, costs: MutableGrid<Int>, x: Int, y: Int, cost: Int, bytes: Int) {
+        costs[x, y] = cost
+        val newCost = cost + 1
+        for (d in Dir4.entries) {
+            val x = x + d.x
+            val y = y + d.y
+            if (input.getIfInBounds(x, y) { 0 } >= bytes && newCost < costs[x, y]) {
+                populateCosts(input, costs, x, y, newCost, bytes)
+            }
+        }
+    }
+
+    fun solvePart1(input: Grid<Int>, bytes: Int): Int {
+        val costs = IntGrid(input.width, input.height, Int.MAX_VALUE)
+        populateCosts(input, costs, 0, 0, 0, bytes)
+        return costs[input.width-1, input.height-1]
+    }
+
+    override fun solvePart1(input: Grid<Int>): String {
+        return solvePart1(input, 1024).toString()
+    }
+
+    override fun solvePart2(input: Grid<Int>): String {
+        // It should be brute forceable
+        // It's slow, but probably less so than me implementing a quicker algo
+        // I'll make nice later
+        for (i in 1..input.max()) {
+            val result = solvePart1(input, i)
+            if (result == Int.MAX_VALUE) {
+                return with (input.iterableWithPos().first { it.data == i-1 }) { "$x,$y" }
+            }
+        }
+        error("No solution")
+    }
+
+}
+
+fun main() {
+    Harness.run(Day18)
+}

src/main/kotlin/com/cluddles/aoc/y2024/Day18.kt

@@ -0,0 +1,21 @@
+package com.cluddles.aoc.y2024
+
+import com.cluddles.aoc.core.SolverInput
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class Day18Test {
+
+    val solver = Day18
+
+    val input = solver.prepareInput(SolverInput.fromPath(solver.examplePath), 7, 7)
+
+    @Test fun part1() {
+        assertThat(solver.solvePart1(input, 12)).isEqualTo(22)
+    }
+
+    @Test fun part2() {
+        assertThat(solver.solvePart2(input)).isEqualTo("6,1")
+    }
+
+}

src/test/kotlin/com/cluddles/aoc/y2024/Day18Test.kt

@@ -0,0 +1,25 @@
+5,4
+4,2
+4,5
+3,0
+2,1
+6,3
+2,4
+1,5
+0,6
+3,3
+2,6
+5,1
+1,2
+5,5
+2,5
+6,5
+1,4
+0,4
+6,4
+1,1
+6,1
+1,0
+0,5
+1,6
+2,0