Improve solution 2018-15, part 2 (Beverage Bandits)

By stop searching for paths to further targets as soon as all paths to targets
that are the minimal distance away, on an M$ Surface 8 part 2 terminates in
12 seconds instead of approx 1 minute.

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/extensions/graphs/shortestpath/Dijkstra.kt

@@ -15,8 +15,13 @@ data class DijkstraResult<V>(val distances: Map<V, Int>, val predecessors: Map<V
 /**
  * @return A list containing one shortest path from [source] to each target in [targets] in the [graph].
  */
-fun <V> dijkstra(graph: Graph<V>, source: V, targets: List<V>): List<ShortestPath<V>> {
-    val dijkstraResult = dijkstra(graph, source)
+fun <V> dijkstraShortestPaths(
+    graph: Graph<V>,
+    source: V,
+    targets: List<V>,
+    stopAfterMinimalPathsAreFound: Boolean = false,
+): List<ShortestPath<V>> {
+    val dijkstraResult = dijkstra(graph, source, targets, stopAfterMinimalPathsAreFound)
     return targets.mapNotNull { reconstructPath(dijkstraResult, source, it) }
 }
 
@@ -28,14 +33,30 @@ fun <V> dijkstra(graph: Graph<V>, source: V, targets: List<V>): List<ShortestPat
  *
  * While traversing, when more than one vertex has the same minimal distance to the current one, the vertex that comes
  * first in the [graph]'s `vertices` list is chosen.
+ *
+ * @param stopAfterMinimalPathsAreFound If `true`, the algorithm stops as soon as all minimal paths (i.e. paths of the
+ * same, minimal length to arbitrary vertices in the [targets] list) have been found.
  */
-fun <V> dijkstra(graph: Graph<V>, source: V): DijkstraResult<V> {
+fun <V> dijkstra(
+    graph: Graph<V>,
+    source: V,
+    targets: List<V>,
+    stopAfterMinimalPathsAreFound: Boolean = false,
+): DijkstraResult<V> {
     val dist = mutableMapOf(source to 0).withDefault { LARGE_VALUE }
     val prev = mutableMapOf<V, V>()
     val q = graph.vertices.toMutableList()
 
+    var minimalDistance = LARGE_VALUE
     while (q.isNotEmpty()) {
         val u = q.minBy { dist.getValue(it) }
+        if (stopAfterMinimalPathsAreFound && u in targets) {
+            if (minimalDistance == LARGE_VALUE) {
+                minimalDistance = dist.getValue(u)
+            } else if (minimalDistance < dist.getValue(u)) {
+                break
+            }
+        }
         q.remove(u)
 
         for (v in q) {

src/main/kotlin/de/ronny_h/aoc/extensions/grids/Grid.kt

@@ -3,7 +3,7 @@ package de.ronny_h.aoc.extensions.grids
 import de.ronny_h.aoc.extensions.graphs.shortestpath.Graph
 import de.ronny_h.aoc.extensions.graphs.shortestpath.ShortestPath
 import de.ronny_h.aoc.extensions.graphs.shortestpath.aStarAllPaths
-import de.ronny_h.aoc.extensions.graphs.shortestpath.dijkstra
+import de.ronny_h.aoc.extensions.graphs.shortestpath.dijkstraShortestPaths
 import java.io.ByteArrayOutputStream
 import java.io.PrintStream
 import java.nio.charset.StandardCharsets
@@ -218,6 +218,7 @@ abstract class Grid<T>(
     fun shortestPaths(
         start: Coordinates,
         goals: List<Coordinates>,
+        stopAfterMinimalPathsAreFound: Boolean = false,
         isObstacle: (T) -> Boolean = { it == nullElement },
     ): List<ShortestPath<Coordinates>> {
         val graph = Graph(
@@ -228,7 +229,7 @@ abstract class Grid<T>(
                 if (to in from.neighbours().filter { !isObstacle(getAt(it)) }) 1 else null
             }
         )
-        return dijkstra(graph, start, goals)
+        return dijkstraShortestPaths(graph, start, goals, stopAfterMinimalPathsAreFound)
     }
 
     /**

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

@@ -112,6 +112,7 @@ class CombatArea(input: List<String>, val elfAttackPower: Int = 3) : SimpleCharG
         val shortestPaths = shortestPaths(
             start = position,
             goals = targetsInRange,
+            stopAfterMinimalPathsAreFound = true,
             isObstacle = { it != cavern })
 
         if (shortestPaths.isEmpty()) {

src/test/kotlin/de/ronny_h/aoc/extensions/graphs/shortestpath/ShortestPathTest.kt

@@ -63,7 +63,7 @@ class ShortestPathTest : StringSpec({
             )
         )
         aStar(start, goal::positionEquals, neighbours, d, h) shouldBe ShortestPath(listOf(start, goal), 1)
-        dijkstra(Graph(listOf(start, goal), d), start, listOf(goal)) shouldBe listOf(
+        dijkstraShortestPaths(Graph(listOf(start, goal), d), start, listOf(goal)) shouldBe listOf(
             ShortestPath(
                 listOf(start, goal),
                 1
@@ -100,7 +100,7 @@ class ShortestPathTest : StringSpec({
                 ShortestPath(listOf(start, a, goal), 10)
 
         val edges: (Node, Node) -> Int? = { m, n -> distances[m to n] }
-        dijkstra(Graph(listOf(start, a, b, goal), edges), start, listOf(goal)) shouldBe
+        dijkstraShortestPaths(Graph(listOf(start, a, b, goal), edges), start, listOf(goal)) shouldBe
                 listOf(ShortestPath(listOf(start, a, goal), 10))
     }
 
@@ -128,7 +128,7 @@ class ShortestPathTest : StringSpec({
                 listOf(ShortestPath(listOf(start, a, goal), 9))
         aStar(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe
                 ShortestPath(listOf(start, a, goal), 9)
-        dijkstra(Graph(listOf(start, a, goal), d), start, listOf(goal)) shouldBe
+        dijkstraShortestPaths(Graph(listOf(start, a, goal), d), start, listOf(goal)) shouldBe
                 listOf(ShortestPath(listOf(start, a, goal), 9))
     }
 
@@ -160,7 +160,7 @@ class ShortestPathTest : StringSpec({
                 listOf(ShortestPath(listOf(start, a, goal), 9))
         aStar(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe
                 ShortestPath(listOf(start, a, goal), 9)
-        dijkstra(Graph(listOf(start, a, goal), d), start, listOf(goal)) shouldBe
+        dijkstraShortestPaths(Graph(listOf(start, a, goal), d), start, listOf(goal)) shouldBe
                 listOf(ShortestPath(listOf(start, a, goal), 9))
     }
 
@@ -193,7 +193,7 @@ class ShortestPathTest : StringSpec({
                 ShortestPath(listOf(start, a, b, goal), 9)
 
         val edges: (Node, Node) -> Int? = { m, n -> distances[m to n] }
-        dijkstra(Graph(listOf(start, a, b, goal), edges), start, listOf(goal)) shouldBe
+        dijkstraShortestPaths(Graph(listOf(start, a, b, goal), edges), start, listOf(goal)) shouldBe
                 listOf(ShortestPath(listOf(start, a, b, goal), 9))
     }
 
@@ -205,7 +205,7 @@ class ShortestPathTest : StringSpec({
         val h: (Node) -> Int = { n -> n.position taxiDistanceTo goal.position }
 
         aStarAllPaths(start, goal::positionEquals, { emptyList() }, d, h) shouldBe emptyList()
-        dijkstra(Graph(listOf(start, goal), { _, _ -> null }), start, listOf(goal)) shouldBe emptyList()
+        dijkstraShortestPaths(Graph(listOf(start, goal), { _, _ -> null }), start, listOf(goal)) shouldBe emptyList()
 
         shouldThrow<IllegalStateException> { aStar(start, goal::positionEquals, { emptyList() }, d, h) }
     }

src/test/kotlin/de/ronny_h/aoc/extensions/grids/SimpleCharGridTest.kt

@@ -179,6 +179,38 @@ class SimpleCharGridTest : StringSpec({
         )
     }
 
+    "the Dijkstra implementation stopAfterMinimalPathsAreFound if that option is set" {
+        val input = """
+            SoG
+            o.o
+            G.G
+            ..G
+        """.asList()
+        SimpleCharGrid(input)
+            .shortestPaths(
+                start = C(0, 0),
+                goals = listOf(C(0, 2), C(2, 0), C(2, 2), C(3, 2)),
+                stopAfterMinimalPathsAreFound = true,
+            ) shouldBe listOf(
+            ShortestPath(
+                listOf(
+                    C(0, 0), C(0, 1), C(0, 2),
+                ), 2
+            ),
+            ShortestPath(
+                listOf(
+                    C(0, 0), C(1, 0), C(2, 0),
+                ), 2
+            ),
+            // to know when all minimal paths are found, the algorithm has to continue to the next larger one
+            ShortestPath(
+                listOf(
+                    C(0, 0), C(0, 1), C(0, 2), C(1, 2), C(2, 2),
+                ), 4
+            ),
+        )
+    }
+
     "the Dijkstra implementation ignores unreachable goals" {
         val input = """
             1#2