Add linear on path solution to 2024 day 18 part 2

Author: sim642

src/main/scala/eu/sim642/adventofcode2024/Day18.scala

@@ -4,6 +4,8 @@ import eu.sim642.adventofcodelib.OrderedSearch
 import eu.sim642.adventofcodelib.graph.{BFS, GraphSearch, TargetNode, UnitNeighbors}
 import eu.sim642.adventofcodelib.pos.Pos
 
+import scala.annotation.tailrec
+
 object Day18 {
 
   def bytesGraphSearch(bytes: Seq[Pos], max: Pos = Pos(70, 70), after: Int = 1024): GraphSearch[Pos] & UnitNeighbors[Pos] & TargetNode[Pos] = {
@@ -30,16 +32,51 @@ object Day18 {
     BFS.search(graphSearch).target.get._2
   }
 
-  def exitReachable(bytes: Seq[Pos], max: Pos, after: Int): Boolean = {
-    val graphSearch = bytesGraphSearch(bytes, max, after)
-    BFS.search(graphSearch).target.isDefined
+  trait Part2Solution {
+    def findBlockingByte(bytes: Seq[Pos], max: Pos = Pos(70, 70)): Pos
+
+    def findBlockingByteString(bytes: Seq[Pos], max: Pos = Pos(70, 70)): String = {
+      val blockingByte = findBlockingByte(bytes, max)
+      s"${blockingByte.x},${blockingByte.y}"
+    }
   }
 
-  def findBlockingByte(bytes: Seq[Pos], max: Pos = Pos(70, 70)): String = {
-    def f(after: Int): Boolean = !exitReachable(bytes, max, after)
-    val blockingAfter = OrderedSearch.binaryLower(f, 0, bytes.size + 1)(true)
-    val blockingByte = bytes(blockingAfter - 1)
-    s"${blockingByte.x},${blockingByte.y}"
+  object BinarySearchPart2Solution extends Part2Solution {
+    def exitReachable(bytes: Seq[Pos], max: Pos, after: Int): Boolean = {
+      val graphSearch = bytesGraphSearch(bytes, max, after)
+      BFS.search(graphSearch).target.isDefined
+    }
+
+    override def findBlockingByte(bytes: Seq[Pos], max: Pos = Pos(70, 70)): Pos = {
+      def f(after: Int): Boolean = !exitReachable(bytes, max, after)
+      val blockingAfter = OrderedSearch.binaryLower(f, 0, bytes.size + 1)(true)
+      bytes(blockingAfter - 1)
+    }
+  }
+
+  object LinearOnPathPart2Solution extends Part2Solution {
+    def exitPath(bytes: Seq[Pos], max: Pos, after: Int): Option[Seq[Pos]] = {
+      val graphSearch = bytesGraphSearch(bytes, max, after + 1)
+      BFS.searchPaths(graphSearch).paths.get(graphSearch.targetNode) // TODO: optimize paths to not compute everything
+    }
+
+    override def findBlockingByte(bytes: Seq[Pos], max: Pos = Pos(70, 70)): Pos = {
+
+      @tailrec
+      def helper(after: Int, path: Set[Pos]): Int = {
+        if (path(bytes(after))) {
+          exitPath(bytes, max, after + 1) match {
+            case Some(newPath) => helper(after + 1, newPath.toSet)
+            case None => after + 1
+          }
+        }
+        else
+          helper(after + 1, path)
+      }
+
+      val blockingAfter = helper(0, exitPath(bytes, max, 0).get.toSet)
+      bytes(blockingAfter - 1)
+    }
   }
 
   def parseByte(s: String): Pos = s match {
@@ -51,7 +88,8 @@ object Day18 {
   lazy val input: String = scala.io.Source.fromInputStream(getClass.getResourceAsStream("day18.txt")).mkString.trim
 
   def main(args: Array[String]): Unit = {
+    import BinarySearchPart2Solution._
     println(exitSteps(parseBytes(input)))
-    println(findBlockingByte(parseBytes(input)))
+    println(findBlockingByteString(parseBytes(input)))
   }
 }

src/main/scala/eu/sim642/adventofcodelib/graph/GraphTraversal.scala

@@ -28,6 +28,9 @@ trait Paths[A] {
       node -> (node +: LazyList.unfold0(node)(prevNodes.get)).reverse
     )
   }
+
+  /*def paths(node: A): Seq[A] =
+    (node +: LazyList.unfold0(node)(prevNodes.get)).reverse*/
 }
 
 trait Order[A] {

src/test/scala/eu/sim642/adventofcode2024/Day18Test.scala

@@ -1,10 +1,18 @@
 package eu.sim642.adventofcode2024
 
 import Day18.*
+import Day18Test.*
 import eu.sim642.adventofcodelib.pos.Pos
+import org.scalatest.Suites
 import org.scalatest.funsuite.AnyFunSuite
 
-class Day18Test extends AnyFunSuite {
+class Day18Test extends Suites(
+  new Part1Test,
+  new BinarySearchPart2SolutionTest,
+  new LinearOnPathPart2SolutionTest,
+)
+
+object Day18Test {
 
   val exampleInput =
     """5,4
@@ -33,19 +41,29 @@ class Day18Test extends AnyFunSuite {
       |1,6
       |2,0""".stripMargin
 
-  test("Part 1 examples") {
-    assert(exitSteps(parseBytes(exampleInput), Pos(6, 6), 12) == 22)
-  }
+  class Part1Test extends AnyFunSuite {
+    test("Part 1 examples") {
+      assert(exitSteps(parseBytes(exampleInput), Pos(6, 6), 12) == 22)
+    }
 
-  test("Part 1 input answer") {
-    assert(exitSteps(parseBytes(input)) == 304)
+    test("Part 1 input answer") {
+      assert(exitSteps(parseBytes(input)) == 304)
+    }
   }
 
-  test("Part 2 examples") {
-    assert(findBlockingByte(parseBytes(exampleInput), Pos(6, 6)) == "6,1")
-  }
+  abstract class Part2SolutionTest(part2Solution: Part2Solution) extends AnyFunSuite {
+    import part2Solution._
 
-  test("Part 2 input answer") {
-    assert(findBlockingByte(parseBytes(input)) == "50,28")
+    test("Part 2 examples") {
+      assert(findBlockingByteString(parseBytes(exampleInput), Pos(6, 6)) == "6,1")
+    }
+
+    test("Part 2 input answer") {
+      assert(findBlockingByteString(parseBytes(input)) == "50,28")
+    }
   }
+
+  class BinarySearchPart2SolutionTest extends Part2SolutionTest(BinarySearchPart2Solution)
+
+  class LinearOnPathPart2SolutionTest extends Part2SolutionTest(LinearOnPathPart2Solution)
 }