SimpleCharGrid: A simple Char-based grid with shortestPaths

* shortestPaths() finds all shortest paths from start to goal
* Grid cells are simply identified by their Coordinates
* ShortestPaths is extended to find all possible shortest paths
  (and not just some of them)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/extensions/ShortestPaths.kt

@@ -7,22 +7,21 @@ import kotlin.Int.Companion.MAX_VALUE
 //       https://en.wikipedia.org/wiki/A*_search_algorithm
 
 
-private fun <N> reconstructPaths(cameFrom: Map<N, Collection<N>>, last: N): List<List<N>> {
-    if (!cameFrom.contains(last)) {
-        return listOf(listOf(last))
+private fun <N> reconstructPaths(cameFrom: Map<N, Collection<N>>, currentNode: N): List<List<N>> {
+    if (!cameFrom.contains(currentNode)) {
+        return listOf(listOf(currentNode))
     }
-    return cameFrom.getValue(last)
+    return cameFrom.getValue(currentNode)
         .flatMap { pred -> reconstructPaths(cameFrom, pred) }
-        .map { path -> path + last }
-        .toList()
+        .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
- * @param isGoal predicate deciding if a node is a goal
+ * @param isGoal predicate deciding if a node is the goal
  * @param neighbors is a function that returns the list of neighbours for a given node.
  * @param d is the distance/cost function. d(m,n) provides the distance (or cost) to reach node n from node m.
  * @param h is the heuristic function. h(n) estimates the cost to reach goal from node n.
@@ -33,43 +32,45 @@ fun <N> aStarAllPaths(
 ): List<ShortestPath<N>> {
     // For node n, fScore[n] := gScore[n] + h(n). fScore[n] represents our current best guess as to
     // how cheap a path could be from start to finish if it goes through n.
-    val fScore = mutableMapOf<N, Int>().withDefault { _ -> LARGE_VALUE } // map with default value of Infinity
+    val fScore = mutableMapOf<N, Int>().withDefault { _ -> LARGE_VALUE } // map with default value of "Infinity"
 
     // The set of discovered nodes that may need to be (re-)expanded.
     // Initially, only the start node is known.
     // This is usually implemented as a min-heap or priority queue rather than a hash-set.
-    val openSet =
-        PriorityQueue<N> { a, b -> fScore.getValue(a).compareTo(fScore.getValue(b)) }
+    val openSet = PriorityQueue<N> { a, b -> fScore.getValue(a).compareTo(fScore.getValue(b)) }
     openSet.add(start)
 
-    // For node n, cameFrom[n] is the list of nodes immediately preceding it on the cheapest paths from the start
+    // For node n, cameFrom[n] is the set of nodes immediately preceding it on the cheapest paths from the start
     // to n currently known.
     val cameFrom = mutableMapOf<N, MutableSet<N>>()
 
     // For node n, gScore[n] is the currently known cost of the cheapest path from start to n.
-    val gScore = mutableMapOf<N, Int>().withDefault { _ -> LARGE_VALUE } // map with default value of Infinity
+    val gScore = mutableMapOf<N, Int>().withDefault { _ -> LARGE_VALUE } // map with default value of "Infinity"
     gScore[start] = 0
-
     fScore[start] = h(start)
 
     while (openSet.isNotEmpty()) {
         // This operation can occur in O(Log(N)) time if openSet is a min-heap or a priority queue
-        val current = openSet.peek()
+        val current = openSet.remove()
         if (current.isGoal()) {
-            return reconstructPaths(cameFrom, current).map { x -> ShortestPath(x, gScore.getValue(current)) }
+            // Search for nodes in openSet with fScore[node] <= gScore[current]
+            // If the heuristic function is admissible (it never overestimates the actual cost to get to the goal)
+            // we can be sure to expand all possible paths.
+            if (openSet.all { n -> fScore.getValue(n) > gScore.getValue(current) }) {
+                return reconstructPaths(cameFrom, current).map { x -> ShortestPath(x, gScore.getValue(current)) }
+            }
         }
 
-        openSet.remove(current)
         for (neighbor in neighbors(current)) {
             // d(current,neighbor) is the weight of the edge from current to neighbor
-            // tentative_gScore is the distance from start to the neighbor through current
+            // tentativeGScore is the distance from start to the neighbor through current
             val tentativeGScore = gScore.getValue(current) + d(current, neighbor)
             if (tentativeGScore <= gScore.getValue(neighbor)) {
                 if (tentativeGScore < gScore.getValue(neighbor)) {
                     // This path to neighbor is better than any previous one. Record it!
                     cameFrom[neighbor] = mutableSetOf(current)
                 } else {
-                    // This path to neighbor is equal to the best one. Record it!
+                    // This path to neighbor is equal to the best one. Record it, too!
                     cameFrom.getOrPut(neighbor) { mutableSetOf() } += current
                 }
                 gScore[neighbor] = tentativeGScore

src/main/kotlin/de/ronny_h/aoc/extensions/SimpleCharGrid.kt

@@ -0,0 +1,23 @@
+package de.ronny_h.aoc.extensions
+
+class SimpleCharGrid(input: List<String>, nullElement: Char = '#') : Grid<Char>(input, nullElement) {
+    override fun Char.toElementType() = this
+
+    fun shortestPaths(start: Coordinates, goal: Coordinates): List<ShortestPath<Coordinates>> {
+        val neighbours: (Coordinates) -> List<Coordinates> = { position ->
+            Direction
+                .entries
+                .map { position + it }
+                .filter { getAt(it) != nullElement }
+        }
+
+        val d: (Coordinates, Coordinates) -> Int = { a, b ->
+            check(a taxiDistanceTo b == 1) // pre-condition: a and b a neighbours
+            1
+        }
+
+        val h: (Coordinates) -> Int = { it taxiDistanceTo goal }
+
+        return aStarAllPaths(start, { this == goal }, neighbours, d, h)
+    }
+}

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

@@ -0,0 +1,42 @@
+package de.ronny_h.aoc.extensions
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
+import io.kotest.matchers.shouldBe
+import de.ronny_h.aoc.extensions.Coordinates as C
+
+class SimpleCharGridTest : StringSpec({
+
+    "in a grid with a unique shortest path that path is found" {
+        SimpleCharGrid(listOf("12", "34")).shortestPaths(C(0, 0), C(0, 1)) shouldBe
+                listOf(ShortestPath(listOf(C(0, 0), C(0, 1)), 1))
+    }
+
+    "in a small grid with multiple shortest paths all paths are found" {
+        SimpleCharGrid(listOf("12", "34")).shortestPaths(C(0, 0), C(1, 1)) shouldBe
+                listOf(
+                    ShortestPath(listOf(C(0, 0), C(0, 1), C(1, 1)), 2),
+                    ShortestPath(listOf(C(0, 0), C(1, 0), C(1, 1)), 2),
+                )
+    }
+
+    "in a slightly larger grid with multiple shortest paths all paths are found" {
+        SimpleCharGrid(listOf("123", "456", "789")).shortestPaths(C(0, 0), C(2, 2)) shouldContainExactlyInAnyOrder
+                listOf(
+                    ShortestPath(listOf(C(0, 0), C(0, 1), C(0, 2), C(1, 2), C(2, 2)), 4),
+                    ShortestPath(listOf(C(0, 0), C(0, 1), C(1, 1), C(1, 2), C(2, 2)), 4),
+                    ShortestPath(listOf(C(0, 0), C(0, 1), C(1, 1), C(2, 1), C(2, 2)), 4),
+                    ShortestPath(listOf(C(0, 0), C(1, 0), C(1, 1), C(1, 2), C(2, 2)), 4),
+                    ShortestPath(listOf(C(0, 0), C(1, 0), C(1, 1), C(2, 1), C(2, 2)), 4),
+                    ShortestPath(listOf(C(0, 0), C(1, 0), C(2, 0), C(2, 1), C(2, 2)), 4),
+                )
+    }
+
+    "in a non-rectangular grid with multiple shortest paths all paths are found" {
+        SimpleCharGrid(listOf("#12", "345"), '#').shortestPaths(C(0, 1), C(1, 2)) shouldContainExactlyInAnyOrder
+                listOf(
+                    ShortestPath(listOf(C(0, 1), C(0, 2), C(1, 2)), 2),
+                    ShortestPath(listOf(C(0, 1), C(1, 1), C(1, 2)), 2),
+                )
+    }
+})