ShortestPath: Instead of passing the goal node, pass a function

The function `isGoal` is a predicate stating if the current node equals the
goal node.

Author: rhaendel

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

@@ -23,12 +23,12 @@ private const val LARGE_VALUE = MAX_VALUE / 2
 /**
  * A* finds a path from `start` to `goal`.
  * @param start the start node
- * @param goal the goal 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> aStar(start: N, goal: N, neighbors: (N) -> List<N>, d: (N, N) -> Int, h: (N) -> Int,
+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 = {_, _, _ -> }): 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.
@@ -53,7 +53,7 @@ fun <N> aStar(start: N, goal: N, neighbors: (N) -> List<N>, d: (N, N) -> Int, h:
     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 == goal) {
+        if (isGoal(current)) {
             return ShortestPath(reconstructPath(cameFrom, current), gScore.getValue(current))
         }
 
@@ -78,5 +78,5 @@ fun <N> aStar(start: N, goal: N, neighbors: (N) -> List<N>, d: (N, N) -> Int, h:
     }
 
     // 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")
 }

src/main/kotlin/de/ronny_h/aoc/year24/day18/RAMRun.kt

@@ -58,6 +58,6 @@ private class MemorySpace(width: Int, corrupted: List<Coordinates>) : Grid<Char>
 
         val h: (Coordinates) -> Int = { it taxiDistanceTo goal }
 
-        return aStar(start, goal, neighbours, d, h)
+        return aStar(start, { this == goal }, neighbours, d, h)
     }
 }

src/main/kotlin/de/ronny_h/aoc/year24/day20/RaceCondition.kt

@@ -42,7 +42,7 @@ private class RaceTrack(input: List<String>) : Grid<Char>(input, '#') {
 
         val h: (Coordinates) -> Int = { it taxiDistanceTo goal }
 
-        return aStar(start, goal, neighbours, d, h)
+        return aStar(start, { this == goal }, neighbours, d, h)
     }
 
     fun countAllShortcutsSavingAtLeast(minToSave: Int, shortcutMaxLength: Int): Int {

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

@@ -60,7 +60,7 @@ class ShortestPathTest : StringSpec({
                 1
             )
         )
-        aStar(start, goal, neighbours, d, h) shouldBe ShortestPath(listOf(start, goal), 1)
+        aStar(start, goal::positionEquals, neighbours, d, h) shouldBe ShortestPath(listOf(start, goal), 1)
     }
 
     "With 2 different nodes between start and goal, the shorter path is taken" {
@@ -88,7 +88,7 @@ class ShortestPathTest : StringSpec({
 
         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
+        aStar(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe
                 ShortestPath(listOf(start, a, goal), 10)
     }
 
@@ -114,7 +114,7 @@ class ShortestPathTest : StringSpec({
 
         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
+        aStar(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe
                 ShortestPath(listOf(start, a, goal), 9)
     }
 
@@ -144,7 +144,7 @@ class ShortestPathTest : StringSpec({
 
         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
+        aStar(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe
                 ShortestPath(listOf(start, a, goal), 9)
     }
 
@@ -173,7 +173,7 @@ class ShortestPathTest : StringSpec({
 
         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
+        aStar(start, goal::positionEquals, { n -> neighbours.getValue(n) }, d, h) shouldBe
                 ShortestPath(listOf(start, a, b, goal), 9)
     }
 })