DynamicSolver still does not work fully, but at least somehow

Author: portnov

python/graphs.py

@@ -76,8 +76,6 @@ def guess(self, rooms, starting_room, connections):
         for vert_idx, label in enumerate(rooms):
             if self.labels[vert_idx] != label:
                 errors.append(f"Label of room #{vert_idx} label != actual label {self.labels[vert_idx]}")
-        if errors:
-            return errors
         if starting_room != 0:
             errors.append(f"Starting room index {starting_room} is not equal to actual 0")
             return errors

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

@@ -41,11 +41,20 @@ 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]], visitedRooms: Vector[Vector[Int]]) derives ReadWriter {
+case class KnowledgeHolder(
+            problemSize: Int,
+            visitedRoutes: Vector[Vector[Int]],
+            visitedRooms: Vector[Vector[Int]],
+            lastExploreRequest: Vector[Vector[Int]],
+            lastExploreResult : Vector[Vector[Int]]
+        ) derives ReadWriter {
     def incorporateKnowledge(plans: Seq[Seq[Int]], results: Seq[Seq[Int]]): KnowledgeHolder =
         KnowledgeHolder(
+            this.problemSize,
             this.visitedRoutes ++ plans.map(_.toVector),
-            this.visitedRooms ++ visitedRooms.map(_.toVector)
+            this.visitedRooms ++ results.map(_.toVector),
+            plans.map(_.toVector).toVector,
+            results.map(_.toVector).toVector
         )
 }
 

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

@@ -35,6 +35,7 @@ object DynamicSolver {
                         val existingCandidateDoors = g.findFreeDoors(existingCandidateRooms(targetRoomOffset).uid)
                         if (existingCandidateDoors.length > targetDoorOffset) {
                             val nextDoor = existingCandidateDoors(targetDoorOffset)
+                            println(s"Connect room #${input.roomFromUid} door ${input.doorIdx} to room ${nextDoor.roomUid}, door ${nextDoor.idx}")
                             StepApplied(
                                 g.connectRooms(input.roomFromUid, input.doorIdx, nextDoor.roomUid, nextDoor.idx),
                                 nextDoor
@@ -48,6 +49,7 @@ object DynamicSolver {
                         if (freeRooms.length > freeRoomOffset) {
                             val freeRoom = freeRooms(freeRoomOffset)
                             val labeledGraph = g.setRoomLabel(freeRoom.uid, Some(input.roomToLabel))
+                            println(s"Connect room #${input.roomFromUid} door ${input.doorIdx} to room ${freeRoom.uid}, door ${0}")
                             StepApplied(
                                 labeledGraph.connectRooms(input.roomFromUid, input.doorIdx, freeRoom.uid, 0),
                                 DoorVertex(freeRoom.uid, 0)
@@ -58,6 +60,7 @@ object DynamicSolver {
                     }
                 }
                 case Some(linkedRoom) => {
+                    println(s"Room #${input.roomFromUid} door ${input.doorIdx} was already connected to room #${linkedRoom.uid} (label ${linkedRoom.label})")
                     if (linkedRoom.label == Some(input.roomToLabel)) {
                         val nextDoor = g.adjacentDoor(g.doors(input.roomFromUid)(input.doorIdx)).get
                         StepApplied(g, nextDoor)
@@ -70,24 +73,32 @@ object DynamicSolver {
 
     def processStepEnumerating(graph : MyGraph, inputs : Seq[LabelInput], currentRoomUid : Int = 0, roomOffset : Int = 0, doorOffset : Int = 0) : SolverStepResult =
         if (inputs.length == 0) {
+            println("no inputs left")
             StepApplied(graph, DoorVertex(currentRoomUid, 0))
         } else {
             val stepInput = StepInput(currentRoomUid, inputs.head.doorIdx, inputs.head.roomToLabel)
             val stepResult = processStep(graph, stepInput, roomOffset, doorOffset)
             stepResult match {
                 case StepApplied(newGraph, door) =>
                     println(f"Step into; remaining length is ${inputs.tail.length}")
-                    return processStepEnumerating(newGraph, inputs.tail, currentRoomUid = door.roomUid)
+                    val subResult = processStepEnumerating(newGraph, inputs.tail, currentRoomUid = door.roomUid)
+                    println(s"Returning from recursive call: $subResult")
+                    subResult match {
+                        case StepApplied(_,_) => return subResult
+                        case _ =>
+                            println(s"Do rollback; remaining length is ${inputs.length}")
+                            return processStepEnumerating(graph, inputs, currentRoomUid, roomOffset = roomOffset, doorOffset = doorOffset+1)
+                    }
                 case TargetDoorsExhausted() =>
                     println("Doors exhausted")
-                    return processStepEnumerating(graph, inputs, roomOffset+1, 0)
+                    return processStepEnumerating(graph, inputs, 0, roomOffset+1, 0)
                 case TargetRoomsExhausted() =>
                     println("Rooms exhausted")
                     return TargetRoomsExhausted()
                 case Contradiction() =>
                     println("Contradiction")
-                    return processStepEnumerating(graph, inputs, currentRoomUid, roomOffset = roomOffset, doorOffset = doorOffset+1)
-                    // return Rollback()
+                    //return processStepEnumerating(graph, inputs, currentRoomUid, roomOffset = roomOffset, doorOffset = doorOffset+1)
+                    return Rollback()
                 case Rollback() =>
                     println("Rollback")
                     return processStepEnumerating(graph, inputs, currentRoomUid, roomOffset = roomOffset, doorOffset = doorOffset+1)

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

@@ -11,7 +11,7 @@ object Solver {
         Ædificium.select(problem.name)
         println(s"${problem.name} has been selected.")
 
-        var knowledge = KnowledgeHolder(Vector.empty, Vector.empty)
+        var knowledge = KnowledgeHolder(problem.size, Vector.empty, Vector.empty, Vector.empty, Vector.empty)
         while (true) {
             println("Determining next step...")
             val step = nextStep(problem, knowledge)
@@ -84,10 +84,19 @@ object Solver {
         // 6) generate paths to them + finish these routes with random
         // 7) go to 1
 
-        if (knowledge.visitedRoutes.nonEmpty) return Step.StopGuessing()
-
-        val plan = Seq(Lanternarius.shuffle12(problem.maxRouteLength))
-        Step.ExploreStep(plan)
+        //if (knowledge.visitedRoutes.nonEmpty) return Step.StopGuessing()
+        if (knowledge.visitedRoutes.nonEmpty)
+            val res = DynamicSolver.processPlanAndRooms(
+                MyGraph(knowledge.problemSize).setRoomLabel(0, Some(knowledge.lastExploreResult(0)(0))),
+                0,
+                knowledge.lastExploreRequest(0),
+                knowledge.lastExploreResult(0)
+            )
+            val solution = res.get.toSolution
+            Step.GuessStep(solution)
+        else
+            val plan = Seq(Lanternarius.shuffle12(problem.maxRouteLength))
+            Step.ExploreStep(plan)
 
     private def dump(problem: ProblemDefinition, knowledge: KnowledgeHolder, solution: SolutionDefinition): Path =
         val folder = Files.createTempDirectory(s"icfpc.${problem.name}")