Day16, part 1: Fix the neighbours: Either turn or go forward in a single step

Author: rhaendel

src/main/kotlin/Day16.kt

@@ -59,19 +59,7 @@ fun main() {
     )
 
     val input = readInput(day)
-    printAndCheck(input, ::part1, 89471)
-    // too high:  89472
-    // too high:  89471
-    // not right: 88971
-    // not right: 88721
-    // too low:   88472
-
-
-    println("$day part 2")
-
-    fun part2(input: List<String>) = input.size
-
-    printAndCheck(input, ::part2, 6512)
+    printAndCheck(input, ::part1, 89460)
 }
 
 private class ReindeerMaze(input: List<String>) : Grid<Char>(input) {
@@ -80,15 +68,6 @@ private class ReindeerMaze(input: List<String>) : Grid<Char>(input) {
     override fun Char.toElementType() = this
 
     data class Node(val direction: Direction, val position: Coordinates) {
-        // hashCode and equals are used to determine if a Node was already visited.
-        // -> don't distinguish directions
-        override fun hashCode() = position.hashCode()
-        override fun equals(other: Any?): Boolean {
-            if (other !is Node) {
-                return false
-            }
-            return position == other.position
-        }
         override fun toString() = "$position$direction"
     }
 
@@ -102,23 +81,22 @@ private class ReindeerMaze(input: List<String>) : Grid<Char>(input) {
         val goal = Node(Direction.EAST, Coordinates(1, width - 2))
 
         val neighbours: (Node) -> List<Node> = { n ->
-            n.position.directedNeighbours()
-                .filter { !it.first.isOpposite(n.direction) } // don't go back
-                .filter { getAt(it.second) != wall }
-                .map { Node(it.first, it.second) }
+            listOf(
+                Node(n.direction, n.position + n.direction),
+                Node(n.direction.turnLeft(), n.position),
+                Node(n.direction.turnRight(), n.position)
+            ).filter { getAt(it.position) != wall }
         }
 
         val d: (Node, Node) -> Int = { a, b ->
-            require(a.position in b.position.neighbours())
             if (a.position == goal.position && b.position == goal.position) {
                 // direction at goal doesn't care
                 0
-            } else if (a.direction - b.direction == 0) {
+            } else if (a.direction == b.direction) {
                 // straight ahead
                 1
             } else {
-                // turn left, right or u-turn -> turn cost + move cost
-                (a.direction - b.direction) * 1000 + 1
+                1000
             }
         }
 

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

@@ -18,6 +18,8 @@ private fun <N> reconstructPath(cameFrom: Map<N, N>, last: N): List<N> {
 
 data class ShortestPath<N>(val path: List<N>, val distance: Int)
 
+private const val LARGE_VALUE = MAX_VALUE / 2
+
 /**
  * A* finds a path from `start` to `goal`.
  * @param start the start node
@@ -35,7 +37,7 @@ fun <N> aStar(start: N, goal: N, neighbors: (N) -> List<N>, d: (N, N) -> Int, h:
     // 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.getOrDefault(a, LARGE_VALUE).compareTo(fScore.getOrDefault(b, LARGE_VALUE)) }
     openSet.add(start)
 
     // For node n, cameFrom[n] is the node immediately preceding it on the cheapest path from the start
@@ -59,8 +61,8 @@ fun <N> aStar(start: N, goal: N, neighbors: (N) -> List<N>, d: (N, N) -> Int, h:
         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.getOrDefault(current, MAX_VALUE) + d(current, neighbor)
-            if (tentativeGScore < gScore.getOrDefault(neighbor, MAX_VALUE)) {
+            val tentativeGScore = gScore.getOrDefault(current, LARGE_VALUE) + d(current, neighbor)
+            if (tentativeGScore < gScore.getOrDefault(neighbor, LARGE_VALUE)) {
                 // This path to neighbor is better than any previous one. Record it!
                 cameFrom[neighbor] = current
                 gScore[neighbor] = tentativeGScore