Optimizing Ram Run algorithm.

Author: jwcarman

README.md

@@ -37,6 +37,6 @@ Here are the solutions I have implemented along with the time it took to run eac
 | [Day 15: Warehouse Woes](src/test/kotlin/adventofcode/Day15Test.kt) | 129 |
 | [Day 16: Reindeer Maze](src/test/kotlin/adventofcode/Day16Test.kt) | 261 |
 | [Day 17: Chronospatial Computer](src/test/kotlin/adventofcode/Day17Test.kt) | 93 |
-| [Day 18: RAM Run](src/test/kotlin/adventofcode/Day18Test.kt) | 2,608 |
+| [Day 18: RAM Run](src/test/kotlin/adventofcode/Day18Test.kt) | 476 |
 | [Day 19: Linen Layout](src/test/kotlin/adventofcode/Day19Test.kt) | 60 |
 | [Day 20: Race Condition](src/test/kotlin/adventofcode/Day20Test.kt) | 0 |

src/main/kotlin/adventofcode/day18/RamRun.kt

@@ -27,19 +27,27 @@ fun String.parsePoints(): List<Point2D> = lines()
 fun List<Point2D>.generateMap() = TextGrid(List(maxOf { it.y } + 1) { ".".repeat(maxOf { it.x } + 1) })
 
 fun String.findFirstByteThatBlocksExit(): Point2D {
-    val points = parsePoints()
+    val bytes = parsePoints()
+    val xRange = 0..bytes.maxOf { it.x }
+    val yRange = 0..bytes.maxOf { it.y }
 
     val start = Point2D.origin()
-    val xRange = 0..points.maxOf { it.x }
-    val yRange = 0..points.maxOf { it.y }
     val end = Point2D(xRange.last, yRange.last)
-    val fallen = mutableSetOf<Point2D>()
+    val fallenBytes = mutableSetOf<Point2D>()
     val neighbors =
-        { p: Point2D -> p.neighbors().filter { it.x in xRange && it.y in yRange }.filter { it !in fallen } }
-    return points.first { p ->
-        fallen.add(p)
-        Graphs.bfs(start, end, neighbors).isEmpty()
+        { p: Point2D -> p.neighbors().filter { it.x in xRange && it.y in yRange }.filter { it !in fallenBytes } }
+    var shortestPath = Graphs.shortestPaths(start, neighbors).pathTo(end).toSet()
+    for(byte in bytes) {
+        fallenBytes.add(byte)
+        if(shortestPath.contains(byte)) {
+            val shortestPaths = Graphs.shortestPaths(start, neighbors)
+            if(!shortestPaths.pathExists(end)) {
+                return byte
+            }
+            shortestPath = shortestPaths.pathTo(end).toSet()
+        }
     }
+    throw IllegalStateException("No byte blocks the exit")
 }
 
 fun String.findShortestPathToExitAfter(nBytes: Int): Int {

src/main/kotlin/adventofcode/util/graph/Graphs.kt

@@ -77,6 +77,46 @@ object Graphs {
             }
         }
 
+    /**
+     * Implementation of Dijkstra's Algorithm
+     * @param start the starting vertex
+     * @param vertices the set of all vertices
+     * @param neighbors a function that returns the neighbors of a vertex
+     * @param weight a function that returns the weight of an edge
+     * @return the shortest paths from the start vertex to all other vertices
+     */
+    fun <V> shortestPaths(
+        start: V,
+        neighbors: (V) -> List<V>,
+        weight: (V, V) -> Double = { _, _ -> 1.0 }
+    ): ShortestPaths<V> {
+        val pred = mutableMapOf<V, V>()
+        val dist = mutableMapOf<V, Double>()
+        val visited = mutableSetOf<V>()
+        dist[start] = 0.0
+        val queue = PriorityQueue { l: V, r: V ->
+            compareDoubles(
+                dist.getOrDefault(l, Double.MAX_VALUE),
+                dist.getOrDefault(r, Double.MAX_VALUE)
+            )
+        }
+        queue.add(start)
+        while (queue.isNotEmpty()) {
+            val vertex = queue.poll()
+            visited.add(vertex)
+            val distanceToVertex = dist.getOrDefault(vertex, Double.MAX_VALUE)
+            neighbors(vertex).filter { it !in visited }.forEach { neighbor ->
+                val distanceThroughVertex = distanceToVertex + weight(vertex, neighbor)
+                if (distanceThroughVertex < dist.getOrDefault(neighbor, Double.MAX_VALUE)) {
+                    pred[neighbor] = vertex
+                    dist[neighbor] = distanceThroughVertex
+                    queue.add(neighbor)
+                }
+            }
+        }
+        return ShortestPaths(start, dist, pred)
+    }
+
     /**
      * Implementation of Dijkstra's Algorithm
      * @param start the starting vertex