Dijkstra: Fix some edge cases

* Prevent an overflow when something is added to the max
  value of edge weights
* Allow the Dijkstra implementation to find no path to a goal
* In a Grid, include the obstacles (all but the nullElement which
  typically is a wall or outside the grid) in the set of vertices
  as well. Especially the start and the goals need to be visitable
  vertices.

Author: rhaendel

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

@@ -16,7 +16,11 @@ private fun <N> reconstructPath(cameFrom: Map<N, N>, last: N): List<N> {
     return totalPath
 }
 
-private const val LARGE_VALUE = MAX_VALUE / 2
+/**
+ * The maximum value for edge weights. In pseudocode of path-searching algorithms
+ * this is typically denoted as infinity (= a value larger than all others).
+ */
+const val LARGE_VALUE = MAX_VALUE / 2
 
 /**
  * A* finds a path from `start` to `goal`.

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

@@ -1,7 +1,6 @@
 package de.ronny_h.aoc.extensions.graphs.shortestpath
 
 import java.util.*
-import kotlin.Int.Companion.MAX_VALUE
 
 // NOTE: This modified A* implementation is based on the pseudocode on the Wikipedia page
 //       https://en.wikipedia.org/wiki/A*_search_algorithm
@@ -16,8 +15,6 @@ private fun <N> reconstructPaths(cameFrom: Map<N, Collection<N>>, currentNode: N
         .map { path -> path + currentNode }
 }
 
-private const val LARGE_VALUE = MAX_VALUE / 2
-
 /**
  * A modified A* algorithm that finds all shortest paths from `start` to `goal`.
  * @param start the start node

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

@@ -17,7 +17,7 @@ data class DijkstraResult<V>(val distances: Map<V, Int>, val predecessors: Map<V
  */
 fun <V> dijkstra(graph: Graph<V>, source: V, targets: List<V>): List<ShortestPath<V>> {
     val dijkstraResult = dijkstra(graph, source)
-    return targets.map { reconstructPath(dijkstraResult, source, it) }
+    return targets.mapNotNull { reconstructPath(dijkstraResult, source, it) }
 }
 
 // NOTE: This implementation of Dijkstra's Algorithm is a 1:1 equivalent in Kotlin to the pseudo code on the Wikipedia page
@@ -27,7 +27,7 @@ fun <V> dijkstra(graph: Graph<V>, source: V, targets: List<V>): List<ShortestPat
  * Dijkstra's algorithm finds the shortest path from node [source] to all vertices in the [graph].
  */
 fun <V> dijkstra(graph: Graph<V>, source: V): DijkstraResult<V> {
-    val dist = mutableMapOf(source to 0).withDefault { Int.MAX_VALUE }
+    val dist = mutableMapOf(source to 0).withDefault { LARGE_VALUE }
     val prev = mutableMapOf<V, V>()
     val q = graph.vertices.toMutableSet()
 
@@ -39,6 +39,7 @@ fun <V> dijkstra(graph: Graph<V>, source: V): DijkstraResult<V> {
         for (v in q) {
             val edgeWeight = graph.edges(u, v) ?: continue
             val alt = dist.getValue(u) + edgeWeight
+            // TODO use <= and take the prev with highest precedence
             if (alt < dist.getValue(v)) {
                 dist[v] = alt
                 prev[v] = u
@@ -49,9 +50,9 @@ fun <V> dijkstra(graph: Graph<V>, source: V): DijkstraResult<V> {
     return DijkstraResult(dist.toMap(), prev.toMap())
 }
 
-private fun <V> reconstructPath(dijkstraResult: DijkstraResult<V>, source: V, target: V): ShortestPath<V> {
+private fun <V> reconstructPath(dijkstraResult: DijkstraResult<V>, source: V, target: V): ShortestPath<V>? {
     if (dijkstraResult.predecessors[target] == null && target != source) {
-        throw IllegalStateException("Target vertex $target is not reachable from $source")
+        return null
     }
 
     val s = mutableListOf<V>()

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

@@ -222,7 +222,7 @@ abstract class Grid<T>(
     ): List<ShortestPath<Coordinates>> {
         val graph = Graph(
             vertices = forEachCoordinates { position, element ->
-                if (isObstacle(element)) null else position
+                if (element == nullElement) null else position
             }.filterNotNull().toSet(),
             edges = { from, to ->
                 if (to in from.neighbours().filter { !isObstacle(getAt(it)) }) 1 else null

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

@@ -197,22 +197,16 @@ class ShortestPathTest : StringSpec({
                 listOf(ShortestPath(listOf(start, a, b, goal), 9))
     }
 
-    "When there is no path at all, aStarAllPaths returns an empty list" {
+    "When there is no path at all, aStarAllPaths and dijkstra return an empty list" {
         val start = Node(At(0, 0))
         val goal = Node(At(0, 10))
 
         val d: (Node, Node) -> Int = { _, _ -> 0 }
         val h: (Node) -> Int = { n -> n.position taxiDistanceTo goal.position }
 
         aStarAllPaths(start, goal::positionEquals, { emptyList() }, d, h) shouldBe emptyList()
+        dijkstra(Graph(setOf(start, goal), { _, _ -> null }), start, listOf(goal)) shouldBe emptyList()
 
         shouldThrow<IllegalStateException> { aStar(start, goal::positionEquals, { emptyList() }, d, h) }
-        shouldThrow<IllegalStateException> {
-            dijkstra(
-                Graph(setOf(start, goal), { _, _ -> null }),
-                start,
-                listOf(goal)
-            )
-        }
     }
 })

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

@@ -182,6 +182,25 @@ class SimpleCharGridTest : StringSpec({
         )
     }
 
+    "the Dijkstra implementation ignores unreachable goals" {
+        val input = """
+            1#2
+            3#4
+            5#6
+        """.asList()
+        SimpleCharGrid(input)
+            .shortestPaths(
+                start = Coordinates(0, 0),
+                goals = listOf(Coordinates(0, 2), Coordinates(2, 0), Coordinates(2, 2))
+            ) shouldBe listOf(
+            ShortestPath(
+                listOf(
+                    Coordinates(0, 0), Coordinates(1, 0), Coordinates(2, 0),
+                ), 2
+            ),
+        )
+    }
+
     "cluster regions of same char with a single region" {
         val input = """
             xx