195 lines
6.5 KiB
Scala
195 lines
6.5 KiB
Scala
|
package aoc.day21
|
||
|
|
||
|
import aoc._
|
||
|
import aoc.direction._
|
||
|
import scala.collection.mutable
|
||
|
|
||
|
val board =
|
||
|
lines
|
||
|
.map(_.toArray)
|
||
|
.toArray
|
||
|
|
||
|
val startPoint =
|
||
|
board.toSeq.zipWithIndex.findMap { (row, idx) =>
|
||
|
row.toSeq.zipWithIndex.findMap: (cell, col) =>
|
||
|
if cell == 'S' then Some((idx, col)) else None
|
||
|
}.get
|
||
|
|
||
|
def inside(x: Int, y: Int) =
|
||
|
x >= 0 && x < board.length && y >= 0 && y < board(0).length
|
||
|
|
||
|
def walkable(x: Int, y: Int) = inside(x, y) && board(x)(y) != '#'
|
||
|
|
||
|
def getInf(x: Int, y: Int) =
|
||
|
def mod(x: Int, m: Int): Int = if x < 0 then mod(x % m + m, m) else x % m
|
||
|
board(mod(x, board.size))(mod(y, board(0).size))
|
||
|
def walkableInf(x: Int, y: Int) = getInf(x, y) != '#'
|
||
|
|
||
|
// part 1
|
||
|
|
||
|
def walk(steps: Int, starting: Set[(Int, Int)]): Set[(Int, Int)] =
|
||
|
if steps == 0 then starting
|
||
|
else
|
||
|
// println(s"$steps => ${starting.size}")
|
||
|
val ns =
|
||
|
starting
|
||
|
.flatMap((a, b) => Dir.all.map(_(a, b)))
|
||
|
.filter(walkableInf(_, _))
|
||
|
walk(steps - 1, ns)
|
||
|
|
||
|
def part1 =
|
||
|
val possible = walk(300, Set(startPoint))
|
||
|
println(possible.size)
|
||
|
|
||
|
// part 2
|
||
|
|
||
|
object shortestPathsFrom:
|
||
|
val cache = mutable.Map.empty[(Int, Int), Array[Array[Int]]]
|
||
|
|
||
|
def apply(x: Int, y: Int) =
|
||
|
cache.getOrElseUpdate(
|
||
|
(x, y), {
|
||
|
val mp = mutable.Map((x, y) -> 0)
|
||
|
val queue = mutable.Queue((x, y))
|
||
|
while !queue.isEmpty do
|
||
|
val (x, y) = queue.dequeue()
|
||
|
val dist = mp((x, y))
|
||
|
Dir.all
|
||
|
.map(_(x, y))
|
||
|
.filter(walkable(_, _))
|
||
|
.foreach { pt =>
|
||
|
if !mp.contains(pt) then
|
||
|
mp += pt -> (dist + 1)
|
||
|
queue += pt
|
||
|
}
|
||
|
val (a, b) = mp.toMap.partition((_, dist) => dist % 2 == 0)
|
||
|
Iterator(a, b)
|
||
|
.map(v => v.values.toSeq.sorted.toArray)
|
||
|
.toArray
|
||
|
}
|
||
|
)
|
||
|
|
||
|
// input is funni
|
||
|
|
||
|
val _ =
|
||
|
assert(board.head.forall(_ == '.'))
|
||
|
assert(board.last.forall(_ == '.'))
|
||
|
assert(board.forall(_.head == '.'))
|
||
|
assert(board.forall(_.last == '.'))
|
||
|
|
||
|
val (x, y) = startPoint
|
||
|
assert((0 until board.length).forall(board(_)(y) != '#'))
|
||
|
assert((0 until board(0).length).forall(board(x)(_) != '#'))
|
||
|
|
||
|
def pointsReachable(steps: Int): Long =
|
||
|
val (sx, sy) = startPoint
|
||
|
def distToRow(delta: Int) =
|
||
|
if delta == 0 then 0L
|
||
|
else if delta < 0 then
|
||
|
// go up
|
||
|
1L + sx + (delta + 1L).abs * board.size
|
||
|
else 0L + (board.size - sx) + (delta - 1L) * board.size
|
||
|
def distToCol(delta: Int) =
|
||
|
if delta == 0 then 0L
|
||
|
else if delta < 0 then
|
||
|
// go left
|
||
|
1L + sy + (delta + 1L).abs * board(0).size
|
||
|
else 0L + (board(0).size - sy) + (delta - 1L) * board(0).size
|
||
|
|
||
|
def startWhere(dx: Int, dy: Int) =
|
||
|
val x = if dx == 0 then sx else if dx < 0 then board.size - 1 else 0
|
||
|
val y = if dy == 0 then sy else if dy < 0 then board(0).size - 1 else 0
|
||
|
(x, y)
|
||
|
|
||
|
def countWhere(steps: Int, dx: Int, dy: Int) =
|
||
|
val dToBoard = distToRow(dx) + distToCol(dy)
|
||
|
if dToBoard > steps then 0L
|
||
|
else
|
||
|
val (stx, sty) = startWhere(dx, dy)
|
||
|
val dists = shortestPathsFrom(stx, sty)((steps - dToBoard).toInt % 2)
|
||
|
val res = dists.sortedCountUntil(steps - dToBoard.toInt).toLong
|
||
|
// println(s"got $dx $dy $dToBoard $stx $sty => $res ${shortestPathsFrom(stx, sty).map(_.size).toSeq}")
|
||
|
res
|
||
|
|
||
|
(-1 to 1).zip((-1 to 1)).foreach { (dx, dy) =>
|
||
|
val (stx, sty) = startWhere(dx, dy)
|
||
|
// println(s"$dx $dy ${shortestPathsFrom(stx, sty).map(_.size).toSeq}")
|
||
|
}
|
||
|
|
||
|
extension (arr: Array[Int])
|
||
|
def sortedCountUntil(max: Int) =
|
||
|
var low = 0
|
||
|
var hi = arr.size
|
||
|
while low < hi do
|
||
|
val mid = (low + hi) / 2
|
||
|
// println(s"$mid => ${arr(mid)} ~ $max")
|
||
|
if arr(mid) <= max then low = mid + 1 else hi = mid
|
||
|
// println(s"found $low => ${arr(low - 1)}")
|
||
|
low
|
||
|
|
||
|
((0 to steps).toIterator
|
||
|
.takeWhile(distToRow(_) <= steps)
|
||
|
++ (-1 to -steps by -1).toIterator.takeWhile(distToRow(_) <= steps))
|
||
|
.map(dx =>
|
||
|
val dRow = distToRow(dx)
|
||
|
val zero = countWhere(steps, dx, 0)
|
||
|
val right =
|
||
|
val (stx, sty) = startWhere(dx, 1)
|
||
|
val baseDistance = dRow + distToCol(1) // dToBoard = baseDistance + (delta-1) * board.size
|
||
|
if baseDistance > steps then 0L
|
||
|
else
|
||
|
val maxRightAllBoard =
|
||
|
((steps - baseDistance - shortestPathsFrom(stx, sty).map(_.last).max) / board.size).toInt.max(0) + 1
|
||
|
val odd = ((steps - baseDistance) % 2).toInt
|
||
|
val a = (1L until maxRightAllBoard by 2).size * shortestPathsFrom(stx, sty)(odd).size
|
||
|
val b = (2L until maxRightAllBoard by 2).size * shortestPathsFrom(stx, sty)((board.size + odd) % 2).size
|
||
|
// println(
|
||
|
// s"$dx => $maxRightAllBoard [${distToRow(dx) + distToCol(maxRightAllBoard)} ${shortestPathsFrom(stx, sty)
|
||
|
// .map(_.last)
|
||
|
// .max}] ${a + b}"
|
||
|
// )
|
||
|
val rest = (maxRightAllBoard to steps).toIterator
|
||
|
.takeWhile(dRow + distToCol(_) <= steps)
|
||
|
.map(countWhere(steps, dx, _))
|
||
|
.sum
|
||
|
a + b + rest
|
||
|
val left =
|
||
|
val (stx, sty) = startWhere(dx, -1)
|
||
|
val baseDistance = dRow + distToCol(-1) // dToBoard = baseDistance + (delta-1) * board.size
|
||
|
if baseDistance > steps then 0L
|
||
|
else
|
||
|
val maxLeftAllBoard =
|
||
|
((steps - baseDistance - shortestPathsFrom(stx, sty).map(_.last).max) / board.size).toInt.max(0) + 1
|
||
|
// println(s"$dx => -$maxLeftAllBoard")
|
||
|
val odd = ((steps - baseDistance) % 2).toInt
|
||
|
val a = (-1L until -maxLeftAllBoard by -2).size * shortestPathsFrom(stx, sty)(odd).size
|
||
|
val b = (-2L until -maxLeftAllBoard by -2).size * shortestPathsFrom(stx, sty)((board.size + odd) % 2).size
|
||
|
// println(s"$dx => -$maxLeftAllBoard [${distToRow(dx) + distToCol(-maxLeftAllBoard)}] ${a + b}")
|
||
|
val rest = (-maxLeftAllBoard to -steps by -1).toIterator
|
||
|
.takeWhile(dRow + distToCol(_) <= steps)
|
||
|
.map(countWhere(steps, dx, _))
|
||
|
.sum
|
||
|
a + b + rest
|
||
|
zero + right + left
|
||
|
)
|
||
|
.sum
|
||
|
|
||
|
def part2 =
|
||
|
val inputs = Seq(26501365)
|
||
|
// val inputs = Seq(1, 131)
|
||
|
println(inputs.map(pointsReachable))
|
||
|
// val s = walk(200, Set(startPoint))
|
||
|
// // divide by quadrant
|
||
|
// val quads = s.toSeq
|
||
|
// .groupBy((x, y) =>
|
||
|
// val qx = if x < 0 then -(-x + board.size - 1) / board.size else x / board.size
|
||
|
// val qy = if y < 0 then -(-y + board(0).size - 1) / board(0).size else y / board(0).size
|
||
|
// (qx, qy)
|
||
|
// )
|
||
|
// .mapValues(_.size)
|
||
|
// println((quads.toSeq, quads.values.sum))
|
||
|
|
||
|
@main def Day21(part: Int) = part match
|
||
|
case 1 => part1
|
||
|
case 2 => part2
|