Refactoring. Calculate from which rooms and doors we could come into each room.

Author: portnov

build.sbt

@@ -4,3 +4,5 @@ libraryDependencies ++= Seq(
     "com.softwaremill.sttp.client4" %% "upickle" % "4.0.10",
     "org.scalatest" %% "scalatest" % "3.2.19" % Test
 )
+
+scalacOptions ++= Seq("-explain")

src/main/scala/ru/org/codingteam/icfpc_2025/Domain.scala

@@ -41,15 +41,15 @@ case class SolutionDefinition(
 case class ConnectionDefinition(from: Door, to: Door) derives ReadWriter
 case class Door(room: Int, door: Int) derives ReadWriter
 
-case class KnowledgeHolder(visitedRoutes: Vector[Vector[Int]], results: Vector[Vector[Int]]) derives ReadWriter {
+case class KnowledgeHolder(visitedRoutes: Vector[Vector[Int]], visitedRooms: Vector[Vector[Int]]) derives ReadWriter {
     def incorporateKnowledge(plans: Seq[Seq[Int]], results: Seq[Seq[Int]]): KnowledgeHolder =
         KnowledgeHolder(
             this.visitedRoutes ++ plans.map(_.toVector),
-            this.results ++ results.map(_.toVector)
+            this.visitedRooms ++ visitedRooms.map(_.toVector)
         )
 }
 
 enum Step:
     case ExploreStep(plans: Seq[Seq[Int]])
     case GuessStep(solution: SolutionDefinition)
-    case StopGuessing()
+    case StopGuessing()

src/main/scala/ru/org/codingteam/icfpc_2025/Solver.scala

@@ -37,32 +37,43 @@ object Solver {
     }
 
     private def nextStep(problem: ProblemDefinition, knowledge: KnowledgeHolder): Step =
-        var ede = Map.empty[(Int, Int), Seq[Int]]
+        // (room, door in that room) -> (possible destination rooms)
+        var roomAndDoorToPossibleRooms = Map.empty[(Int, Int), Seq[Int]]
 
         for (j <- knowledge.visitedRoutes.indices) {
             val plan = knowledge.visitedRoutes(j)
-            val rooms = knowledge.results(j)
+            val rooms = knowledge.visitedRooms(j)
 
             for (i <- plan.indices) {
                 val door = plan(i)
-                val enter = rooms(i)
-                val exit = rooms(i + 1)
+                val roomFrom = rooms(i)
+                val roomTo = rooms(i + 1)
 
-                val key = (enter, door)
+                val key = (roomFrom, door)
 
-                if (!ede.contains(key)) {
-                    ede += (key -> Seq(exit))
-                } else if (!ede(key).contains(exit)) {
-                    ede += (key -> (ede(key) :+ exit))
+                if (!roomAndDoorToPossibleRooms.contains(key)) {
+                    roomAndDoorToPossibleRooms += (key -> Seq(roomTo))
+                } else if (!roomAndDoorToPossibleRooms(key).contains(roomTo)) {
+                    roomAndDoorToPossibleRooms += (key -> (roomAndDoorToPossibleRooms(key) :+ roomTo))
                 }
             }
         }
-
-        val eded: Map[(Int, Int), Seq[(Int, Int)]] =
-            ede.map { case (key @ (a, b), exits) =>
-                val relatedKeys = ede.keys.filter { case (x, y) => exits.contains(x) && ede(x, y).contains(a) }.toSeq
-                key -> relatedKeys
-            }
+        //for ((key, roomsTo) <- roomAndDoorToPossibleRooms)
+        //    println(s"$key => $roomsTo")
+
+        // (room) -> (room from which we could come into room in key, door in source room)
+        var roomToPossibleRoomAndDoorFrom = Map.empty[Int, Set[(Int,Int)]]
+        for ((key, roomsTo) <- roomAndDoorToPossibleRooms) {
+           val roomFrom = key._1
+           val relatedKeys : Set[(Int,Int)] = roomAndDoorToPossibleRooms.keys.filter { case (room, door) => roomsTo.contains(room) && roomAndDoorToPossibleRooms(room, door).contains(roomFrom) }.toSet
+           if (!roomToPossibleRoomAndDoorFrom.contains(roomFrom)) {
+               roomToPossibleRoomAndDoorFrom += (roomFrom -> relatedKeys)
+           } else {
+               roomToPossibleRoomAndDoorFrom += (roomFrom -> (roomToPossibleRoomAndDoorFrom(roomFrom) ++ relatedKeys))
+           }
+        }
+        //for ((key, value) <- roomToPossibleRoomAndDoorFrom)
+        //    println(s"$key => $value")
 
         // I did not implemented it, but someone moore clever than me can implement the following approach:
         // 1) make a walk using routes and map of exit-door <-> possible enter-doors (eded var)
@@ -88,6 +99,6 @@ object Solver {
 private def explore(problem: ProblemDefinition, knowledge: KnowledgeHolder, plans: Seq[Seq[Int]]): KnowledgeHolder =
     println("Exploring the labyrinth...")
     println("Plans:\n" + plans.map(_.mkString(" ")).mkString(start = "- ", sep = "\n", end = ""))
-    val results = Ædificium.explore(plans)
-    println("Exploration results:\n" + results.map(_.mkString(" ")).mkString(start = "- ", sep = "\n", end = ""))
-    knowledge.incorporateKnowledge(plans, results)
+    val visitedRooms = Ædificium.explore(plans)
+    println("Exploration results:\n" + visitedRooms.map(_.mkString(" ")).mkString(start = "- ", sep = "\n", end = ""))
+    knowledge.incorporateKnowledge(plans, visitedRooms)