2018-15, part 1: use Dijkstra's algorithm instead of A*

* Since minimal paths to all targets are calculated in a single call
  of that algorithm, it is much less memory hungry and much faster
  than multiple calls to the A* algorithm.
* Most of the tests pass. But the "in reading order" precedence when
  choosing one of equally expensive vertices still is to implement.
* Since we use a logger in production code, add logback classic
  dependency to the runtime classpath.

Author: rhaendel

build.gradle.kts

@@ -10,6 +10,7 @@ repositories {
 dependencies {
     implementation(libs.kotlin.logging)
     implementation(libs.kotlinx.coroutines.core)
+    runtimeOnly(libs.logback.classic)
 
     testImplementation(libs.kotest.assertions.table)
     testImplementation(libs.kotest.runner.junit5)

src/main/kotlin/de/ronny_h/aoc/year2018/day15/BeverageBandits.kt

@@ -85,16 +85,16 @@ class CombatArea(input: List<String>) : SimpleCharGrid(input) {
             return
         }
 
-        val targetsWithPaths = targets.flatMap { target ->
-            target.position.neighbours()
-                .filter { getAt(it) == cavern }
-                .flatMap { inRange ->
-                    shortestPaths(position, inRange) { neighbour ->
-                        getAt(neighbour) == cavern
-                    }
-                        .map { Target(inRange, it) }
-                }
+        val targetsInRange = targets.flatMap { target ->
+            target.position.neighbours().filter { getAt(it) == cavern }
         }
+        // TODO make path precedence in reading order configurable
+        val targetsWithPaths = shortestPaths(
+            start = position,
+            goals = targetsInRange,
+            isObstacle = { it != cavern })
+            .map { Target(it.path.last(), it) }
+
         if (targetsWithPaths.isEmpty()) {
             // no path to any target found
             return

src/test/kotlin/de/ronny_h/aoc/year2018/day15/BeverageBanditsTest.kt

@@ -2,6 +2,8 @@ package de.ronny_h.aoc.year2018.day15
 
 import de.ronny_h.aoc.extensions.asList
 import io.kotest.core.spec.style.StringSpec
+import io.kotest.data.forAll
+import io.kotest.data.row
 import io.kotest.matchers.shouldBe
 
 class BeverageBanditsTest : StringSpec({
@@ -122,8 +124,64 @@ class BeverageBanditsTest : StringSpec({
         combatArea.takeOneRound() shouldBe false
     }
 
-    "part 1: the outcome of the battle of the small example" {
-        BeverageBandits().part1(input) shouldBe 27730
+    "part 1: the outcome of the battle of some given examples" {
+        val input2 = """
+            #######
+            #G..#E#
+            #E#E.E#
+            #G.##.#
+            #...#E#
+            #...E.#
+            #######
+        """.asList()
+        val input3 = """
+            #######
+            #E..EG#
+            #.#G.E#
+            #E.##E#
+            #G..#.#
+            #..E#.#
+            #######
+        """.asList()
+        val input4 = """
+            #######
+            #E.G#.#
+            #.#G..#
+            #G.#.G#
+            #G..#.#
+            #...E.#
+            #######
+        """.asList()
+        val input5 = """
+            #######
+            #.E...#
+            #.#..G#
+            #.###.#
+            #E#G#G#
+            #...#G#
+            #######
+        """.asList()
+        val input6 = """
+            #########
+            #G......#
+            #.E.#...#
+            #..##..G#
+            #...##..#
+            #...#...#
+            #.G...G.#
+            #.....G.#
+            #########
+        """.asList()
+        forAll(
+            row(input, 27730),
+            row(input2, 36334),
+            row(input3, 39514),
+            row(input4, 27755),
+            row(input5, 28944),
+            row(input6, 18740),
+        ) { input, outcome ->
+            BeverageBandits().part1(input) shouldBe outcome
+        }
     }
 
     "part 2" {