Merge pull request scalacenter#261 from sjrd/make-2022-day-16-fastish-on-js

Make the day16 of 2022 implementation fastish on Scala.js.

Author: bishabosha

2022/src/day16.scala

@@ -12,14 +12,14 @@ import inputs.Input.loadFileSync
 def loadInput(): String = loadFileSync(s"$currentDir/../input/day16")
 
 /*
-Copyright 2022 Tyler Coles (javadocmd.com) & Quentin Bernet
+Copyright 2022 Tyler Coles (javadocmd.com), Quentin Bernet, Sébastien Doeraene and Jamie Thompson
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
-   
+
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -59,7 +59,7 @@ def computeRoutes(start: Id, neighbors: Id => List[Id]): Map[Id, Int] =
 
   case class State(frontier: List[(Id, Int)], scores: Map[Id, Int]):
 
-    private def getScore(id: Id): Int = scores.getOrElse(id, Int.MaxValue) 
+    private def getScore(id: Id): Int = scores.getOrElse(id, Int.MaxValue)
     private def setScore(id: Id, s: Int) = State((id, s + 1) :: frontier, scores + (id -> s))
 
     def dequeued: (Id, State) =
@@ -74,7 +74,7 @@ def computeRoutes(start: Id, neighbors: Id => List[Id]): Map[Id, Int] =
 
   object State:
     def initial(start: Id) = State(List((start, 0)), Map(start -> 0))
-  
+
   def recurse(state: State): State =
     if state.frontier.isEmpty then
       state
@@ -98,27 +98,39 @@ def bestPath(map: RoomsInfo, start: Id, valves: Set[Id], timeAllowed: Int): Int
   // we limit our options by only considering the still-closed valves
   // and `valves` has already culled any room with a flow value of 0 -- no point in considering these rooms!
 
-  def recurse(path: List[Id], valvesLeft: Set[Id], timeLeft: Int, totalValue: Int): Int =
+  val valvesLookup = IArray.from(valves)
+  val valveCount = valvesLookup.size
+  val _activeValveIndices = Array.fill[Boolean](valveCount + 1)(true) // add an extra valve for the initial state
+  def valveIndexLeft(i: Int) = _activeValveIndices(i)
+  def withoutValve(i: Int)(f: => Int) =
+    try
+      _activeValveIndices(i) = false
+      f
+    finally _activeValveIndices(i) = true
+  val roomsByIndices = IArray.tabulate(valveCount)(i => map.rooms(valvesLookup(i)))
+
+  def recurse(hiddenValve: Int, current: Id, timeLeft: Int, totalValue: Int): Int = withoutValve(hiddenValve):
     // recursively consider all plausible options
     // we are finished when we no longer have time to reach another valve or all valves are open
-    valvesLeft
-      .flatMap{ id =>
-        val current  = path.head
-        val distance = map.routes(current)(id)
-        // how much time is left after we traverse there and open the valve?
-        val t = timeLeft - distance - 1
-        // if `t` is zero or less this option can be skipped
-        Option.when(t > 0) {
-          // the value of choosing a particular valve (over the life of our simulation)
-          // is its flow rate multiplied by the time remaining after opening it
-          val value = map.rooms(id).flow * t
-          recurse(id :: path, valvesLeft - id, t, totalValue + value)
-        }
-      }
-      .maxOption
-      .getOrElse { totalValue }
+    val routesOfCurrent = map.routes(current)
+    var bestValue = totalValue
+    for index <- valvesLookup.indices if valveIndexLeft(index) do
+      val id = valvesLookup(index)
+      val distance = routesOfCurrent(id)
+      // how much time is left after we traverse there and open the valve?
+      val t = timeLeft - distance - 1
+      // if `t` is zero or less this option can be skipped
+      if t > 0 then
+        // the value of choosing a particular valve (over the life of our simulation)
+        // is its flow rate multiplied by the time remaining after opening it
+        val value = roomsByIndices(index).flow * t
+        val recValue = recurse(hiddenValve = index, id, t, totalValue + value)
+        if recValue > bestValue then
+          bestValue = recValue
+    end for
+    bestValue
   end recurse
-  recurse(start :: Nil, valves, timeAllowed, 0)
+  recurse(valveCount, start, timeAllowed, 0)
 
 def part1(input: String) =
   val time   = 30
@@ -142,7 +154,7 @@ def part2(input: String) =
   // taking the best of those.
 
   // we can now calculate the efforts separately and sum their values to find the best
-  val allPaths = 
+  val allPaths =
     for va <- valvesA yield
       val vb              = map.valves -- va
       val scoreA = bestPath(map, "AA", va, time)