Solution Day18, part one - the big one

rhaendel · rhaendel · commit b2247ffe50de · 2025-05-29T20:59:39.000+02:00
Restoring the aStar implementation of day 16, part one (the one that
returns just one shortest path), leads to a much faster solution.
diff --git a/src/main/kotlin/Day16.kt b/src/main/kotlin/Day16.kt
@@ -170,7 +170,7 @@ private class ReindeerMaze(input: List<String>) : Grid<Char>(input, '#') {
             println(info.invoke())
         }
 
-        return aStar(start, goal::positionEquals, neighbours, d, h)
+        return aStarAllPaths(start, goal::positionEquals, neighbours, d, h)
     }
 
 }
diff --git a/src/main/kotlin/Day18.kt b/src/main/kotlin/Day18.kt
@@ -1,9 +1,5 @@
 import de.ronny_h.extensions.Coordinates
 import de.ronny_h.extensions.Direction
-import de.ronny_h.extensions.Direction.EAST
-import de.ronny_h.extensions.Direction.NORTH
-import de.ronny_h.extensions.Direction.SOUTH
-import de.ronny_h.extensions.Direction.WEST
 import de.ronny_h.extensions.Grid
 import de.ronny_h.extensions.ShortestPath
 import de.ronny_h.extensions.aStar
@@ -18,9 +14,9 @@ fun main() {
         })
         memorySpace.printGrid()
         println("-----------------")
-        val shortestPaths = memorySpace.shortestPath(Coordinates(0,0), Coordinates(width-1, width-1))
-        memorySpace.printGrid(path = shortestPaths.first().path.associateWith { 'O' })
-        return shortestPaths.first().distance
+        val shortestPath = memorySpace.shortestPath(Coordinates(0,0), Coordinates(width-1, width-1))
+        memorySpace.printGrid(path = shortestPath.path.associateWith { 'O' })
+        return shortestPath.distance
     }
 
     fun part1Small(input: List<String>) = part1(input, 7) // 0..6
@@ -36,7 +32,7 @@ fun main() {
     printAndCheck(testInput.subList(0, 12), ::part1Small, 22)
 
     val input = readInput(day)
-    printAndCheck(input.subList(0, 1024), ::part1Big, 3714264)
+    printAndCheck(input.subList(0, 1024), ::part1Big, 416)
 
 
     println("$day part 2")
@@ -54,7 +50,7 @@ private class MemorySpace(width: Int, corrupted: List<Coordinates>) : Grid<Char>
     private val corrupted = '#'
     override fun Char.toElementType() = this
 
-    fun shortestPath(start: Coordinates, goal: Coordinates): List<ShortestPath<Coordinates>> {
+    fun shortestPath(start: Coordinates, goal: Coordinates): ShortestPath<Coordinates> {
         val neighbours: (Coordinates) -> List<Coordinates> = { node ->
             Direction
                 .entries
@@ -69,6 +65,6 @@ private class MemorySpace(width: Int, corrupted: List<Coordinates>) : Grid<Char>
 
         val h: (Coordinates) -> Int = { it taxiDistanceTo goal}
 
-        return aStar(start, goal::equals, neighbours, d, h)
+        return aStar(start, goal, neighbours, d, h)
     }
 }
diff --git a/src/main/kotlin/de/ronny_h/extensions/ShortestPath.kt b/src/main/kotlin/de/ronny_h/extensions/ShortestPath.kt
@@ -1,79 +1,70 @@
 package de.ronny_h.extensions
 
-import java.util.*
+import java.util.PriorityQueue
 import kotlin.Int.Companion.MAX_VALUE
 
-// NOTE: This modified A* implementation is based on the pseudocode on the Wikipedia page
+// NOTE: This A* implementation is a 1:1 equivalent in Kotlin to the pseudo code on the Wikipedia page
 //       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> reconstructPath(cameFrom: Map<N, N>, last: N): List<N> {
+    var current = last
+    val totalPath = mutableListOf(current)
+    while (current in cameFrom.keys) {
+        current = cameFrom.getValue(current)
+        totalPath.add(0, current)
     }
-    return cameFrom.getValue(last)
-        .flatMap { pred -> reconstructPaths(cameFrom, pred) }
-        .map { path -> path + last }
-        .toList()
+    return totalPath
 }
 
 data class ShortestPath<N>(val path: List<N>, val distance: Int)
 
 private const val LARGE_VALUE = MAX_VALUE / 2
 
 /**
- * A modified A* algorithm that finds all shortest paths from `start` to `goal`.
+ * A* finds a path from `start` to `goal`.
  * @param start the start node
- * @param isGoal predicate deciding if a node is a goal
+ * @param goal the goal node
  * @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.
  */
-fun <N> aStar(
-    start: N, isGoal: N.() -> Boolean, neighbors: (N) -> List<N>, d: (N, N) -> Int, h: (N) -> Int,
-    printIt: (visited: Set<N>, current: N, additionalInfo: () -> String) -> Unit = { _, _, _ -> }
-): List<ShortestPath<N>> {
+fun <N> aStar(start: N, goal: N, neighbors: (N) -> List<N>, d: (N, N) -> Int, h: (N) -> Int,
+              printIt: (visited: Set<N>, current: N, additionalInfo: () -> String) -> Unit = {_, _, _ -> }): 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 node immediately preceding it on the cheapest path from the start
     // to n currently known.
-    val cameFrom = mutableMapOf<N, MutableSet<N>>()
+    val cameFrom = mutableMapOf<N, 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()
-        if (current.isGoal()) {
-            return reconstructPaths(cameFrom, current).map { x -> ShortestPath(x, gScore.getValue(current)) }
+        if (current == goal) {
+            return ShortestPath(reconstructPath(cameFrom, current), 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
             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!
-                    cameFrom.getOrPut(neighbor) { mutableSetOf() } += current
-                }
+            if (tentativeGScore < gScore.getValue(neighbor)) {
+                // This path to neighbor is better than any previous one. Record it!
+                cameFrom[neighbor] = current
                 gScore[neighbor] = tentativeGScore
                 fScore[neighbor] = tentativeGScore + h(neighbor)
                 if (neighbor !in openSet) {
@@ -87,5 +78,5 @@ fun <N> aStar(
     }
 
     // Open set is empty but goal was never reached
-    error("No path found from $start to goal")
+    error("No path found from $start to $goal")
 }
diff --git a/src/main/kotlin/de/ronny_h/extensions/ShortestPaths.kt b/src/main/kotlin/de/ronny_h/extensions/ShortestPaths.kt
@@ -0,0 +1,89 @@
+package de.ronny_h.extensions
+
+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
+
+
+private fun <N> reconstructPaths(cameFrom: Map<N, Collection<N>>, last: N): List<List<N>> {
+    if (!cameFrom.contains(last)) {
+        return listOf(listOf(last))
+    }
+    return cameFrom.getValue(last)
+        .flatMap { pred -> reconstructPaths(cameFrom, pred) }
+        .map { path -> path + last }
+        .toList()
+}
+
+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 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.
+ */
+fun <N> aStarAllPaths(
+    start: N, isGoal: N.() -> Boolean, neighbors: (N) -> List<N>, d: (N, N) -> Int, h: (N) -> Int,
+    printIt: (visited: Set<N>, current: N, additionalInfo: () -> String) -> Unit = { _, _, _ -> }
+): 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
+
+    // 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)) }
+    openSet.add(start)
+
+    // For node n, cameFrom[n] is the list 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
+    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()
+        if (current.isGoal()) {
+            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
+            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!
+                    cameFrom.getOrPut(neighbor) { mutableSetOf() } += current
+                }
+                gScore[neighbor] = tentativeGScore
+                fScore[neighbor] = tentativeGScore + h(neighbor)
+                if (neighbor !in openSet) {
+                    openSet.add(neighbor)
+                }
+            }
+            printIt(cameFrom.keys, neighbor) {
+                "current: $current=${fScore[current]}, neighbor: $neighbor=${fScore[neighbor]}, open: " + openSet.joinToString { "$it=${fScore[it]}" }
+            }
+        }
+    }
+
+    // Open set is empty but goal was never reached
+    error("No path found from $start to goal")
+}
diff --git a/src/test/kotlin/de/ronny_h/extensions/ShortestPathTest.kt b/src/test/kotlin/de/ronny_h/extensions/ShortestPathTest.kt
@@ -54,7 +54,8 @@ class ShortestPathTest : StringSpec({
         val d: (Node, Node) -> Int = { _, _ -> 1 }
         val h: (Node) -> Int = { n -> n.position taxiDistanceTo goal.position }
 
-        aStar(start, goal::positionEquals, neighbours, d, h) shouldBe listOf(ShortestPath(listOf(start, goal), 1))
+        aStarAllPaths(start, goal::positionEquals, neighbours, d, h) shouldBe listOf(ShortestPath(listOf(start, goal), 1))
+        aStar(start, goal, neighbours, d, h) shouldBe ShortestPath(listOf(start, goal), 1)
     }
 
     "With 2 different nodes between start and goal, the shorter path is taken" {
@@ -80,15 +81,10 @@ class ShortestPathTest : StringSpec({
         val d: (Node, Node) -> Int = { m, n -> distances.getValue(m to n) }
         val h: (Node) -> Int = { n -> n.position taxiDistanceTo goal.position }
 
-        aStar(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe listOf(
-            ShortestPath(
-                listOf(
-                    start,
-                    a,
-                    goal
-                ), 10
-            )
-        )
+        aStarAllPaths(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe
+                listOf(ShortestPath(listOf(start, a, goal), 10))
+        aStar(start, goal, { n -> neighbours.getValue(n) }, d, h) shouldBe
+                ShortestPath(listOf(start, a, goal), 10)
     }
 
     "When direct distance from start to goal is longer, the path through a third node is taken" {
@@ -111,15 +107,10 @@ class ShortestPathTest : StringSpec({
         val d: (Node, Node) -> Int = { m, n -> distances.getValue(m to n) }
         val h: (Node) -> Int = { n -> n.position taxiDistanceTo goal.position }
 
-        aStar(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe listOf(
-            ShortestPath(
-                listOf(
-                    start,
-                    a,
-                    goal
-                ), 9
-            )
-        )
+        aStarAllPaths(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe
+                listOf(ShortestPath(listOf(start, a, goal), 9))
+        aStar(start, goal, { n -> neighbours.getValue(n) }, d, h) shouldBe
+                ShortestPath(listOf(start, a, goal), 9)
     }
 
     "The shortest path in a not directed graph is found" {
@@ -146,15 +137,10 @@ class ShortestPathTest : StringSpec({
         val d: (Node, Node) -> Int = { m, n -> distances.getValue(m to n) }
         val h: (Node) -> Int = { n -> n.position taxiDistanceTo goal.position }
 
-        aStar(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe listOf(
-            ShortestPath(
-                listOf(
-                    start,
-                    a,
-                    goal
-                ), 9
-            )
-        )
+        aStarAllPaths(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe
+                listOf(ShortestPath(listOf(start, a, goal), 9))
+        aStar(start, goal, { n -> neighbours.getValue(n) }, d, h) shouldBe
+                ShortestPath(listOf(start, a, goal), 9)
     }
 
     "Distances of 0 can be taken and nodes with same coordinates don't cause problems" {
@@ -180,15 +166,9 @@ class ShortestPathTest : StringSpec({
         val d: (Node, Node) -> Int = { m, n -> distances.getValue(m to n) }
         val h: (Node) -> Int = { n -> n.position taxiDistanceTo goal.position }
 
-        aStar(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe listOf(
-            ShortestPath(
-                listOf(
-                    start,
-                    a,
-                    b,
-                    goal
-                ), 9
-            )
-        )
+        aStarAllPaths(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe
+                listOf(ShortestPath(listOf(start, a, b, goal), 9))
+        aStar(start, goal, { n -> neighbours.getValue(n) }, d, h) shouldBe
+                ShortestPath(listOf(start, a, b, goal), 9)
     }
 })

Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ private class ReindeerMaze(input: List<String>) : Grid<Char>(input, '#') {`
`170`	`170`	`println(info.invoke())`
`171`	`171`	`}`
`172`	`172`
`173`		`- return aStar(start, goal::positionEquals, neighbours, d, h)`
	`173`	`+ return aStarAllPaths(start, goal::positionEquals, neighbours, d, h)`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`}`