Skip to content

Commit 5da64ad

Browse files
stewSquaredstewSquared
committed
Add an article for Day 17 of 2023
1 parent 11cafa0 commit 5da64ad

File tree

1 file changed

+265
-0
lines changed

1 file changed

+265
-0
lines changed

‎docs/2023/puzzles/day17.md

Lines changed: 265 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,8 +6,273 @@ import Solver from "../../../../../website/src/components/Solver.js"
66

77
https://adventofcode.com/2023/day/17
88

9+
## Solution Summary
10+
11+
This is a classic search problem with an interesting restriction on state transformations.
12+
13+
We will solve this using Djikstra's Algorithm to find a path through the grid, using the heat loss of each position as our node weights. However, the states in our priority queue will need to include more than just position and accumulated heat loss, since the streak of forward movements in a given direction affects which positions are accessible from a given state.
14+
15+
Since the restrictions on state transformations differ in part 1 and part 2, we'll model them separately from the base state transformations.
16+
17+
### Framework
18+
19+
First, for convenience, let's introduce classes for presenting position and direction:
20+
21+
```scala
22+
enum Dir:
23+
case N, S, E, W
24+
25+
def turnRight = this match
26+
case Dir.N => E
27+
case Dir.E => S
28+
case Dir.S => W
29+
case Dir.W => N
30+
31+
def turnLeft = this match
32+
case Dir.N => W
33+
case Dir.W => S
34+
case Dir.S => E
35+
case Dir.E => N
36+
37+
case class Point(x: Int, y: Int):
38+
def inBounds = xRange.contains(x) && yRange.contains(y)
39+
40+
def move(dir: Dir) = dir match
41+
case Dir.N => copy(y = y - 1)
42+
case Dir.S => copy(y = y + 1)
43+
case Dir.E => copy(x = x + 1)
44+
case Dir.W => copy(x = x - 1)
45+
```
46+
47+
Since moving forward, turning left, and turning right are common operations, convenience methods for each are included here.
48+
49+
Next, let's work with our input. We'll parse it as a 2D vector of integers:
50+
51+
```scala
52+
val grid: Vector[Vector[Int]] = Vector.from:
53+
val file = loadFileSync(s"$currentDir/../input/day17")
54+
for line <- file.split("\n")
55+
yield line.map(_.asDigit).toVector
56+
```
57+
58+
And now a few convenience methods that need the input:
59+
```scala
60+
val xRange = grid.head.indices
61+
val yRange = grid.indices
62+
63+
def inBounds(p: Point) =
64+
xRange.contains(p.x) && yRange.contains(p.y)
65+
66+
def heatLoss(p: Point) =
67+
if inBounds(p) then grid(p.y)(p.x) else 0
68+
```
69+
70+
### Search State
71+
72+
Now we want to be able to model our state as we're searching. The state will track our position. To know what transitions are possible, we need to keep track of our streak of movements in a given direction. We'll also keep track of the heat lost while getting to a state.
73+
74+
```scala
75+
case class State(pos: Point, dir: Dir, streak: Int):
76+
```
77+
78+
Next let's define some methods for transitioning to new states. We know that we can chose to move forward, turn left, or turn right. For now, we won't consider the restrictions from Part 1 or Part 2 on whether or not you can move forward:
79+
80+
```scala
81+
// inside case class State:
82+
def straight: State =
83+
val newPos = pos.move(dir)
84+
State(pos.move(dir), dir, streak + 1)
85+
86+
def turnLeft: State =
87+
val newDir = dir.turnLeft
88+
val newPos = pos.move(newDir)
89+
State(newPos, newDir, 1)
90+
91+
def turnRight: State =
92+
val newDir = dir.turnRight
93+
val newPos = pos.move(newDir)
94+
State(newPos, newDir, 1)
95+
```
96+
97+
Note that the streak resets to one when we turn right or turn left, since we also move the position forward in that new direction.
98+
99+
### Djikstra's Algorithm
100+
101+
Finally, let's lay the groundwork for an implementation of Djikstra's algorithm.
102+
103+
Since our valid state transformations vary between part 1 and part 2, let's parameterize our search method by a function:
104+
105+
```scala
106+
def search(next: State => List[State]): Int
107+
```
108+
109+
The algorithm uses Map to track the minimum total heat loss for each state, and a Priority Queue prioritizing by this heatloss to choose the next state to visit:
110+
111+
```scala
112+
// inside def search:
113+
import collection.mutable.{PriorityQueue, Map}
114+
115+
val minHeatLoss = Map.empty[State, Int]
116+
117+
given Ordering[State] = Ordering.by(minHeatLoss)
118+
val pq = PriorityQueue.empty[State].reverse
119+
120+
var visiting = State(Point(0, 0), Dir.E, 0)
121+
val minHeatLoss(visiting) = 0
122+
```
123+
124+
As we generate new states to add to the priority Queue, we need to make sure not to add suboptimal states. The first time we visit any state, it will be with a minimum possible cost, because we're visiting this new state from an adjacent minimum heatloss state in our priority queue.
125+
So any state we've already visited will be discarded. This is what our loop will look like:
126+
127+
```scala
128+
// inside def search:
129+
val end = Point(xRange.max, yRange.max)
130+
while visiting.pos != end do
131+
val states = next(visiting).filterNot(minHeatLoss.contains)
132+
states.foreach: s =>
133+
minHeatLoss(s) = minHeatLoss(visiting) + heatLoss(s)
134+
pq.enqueue(s)
135+
visiting = pq.dequeue()
136+
137+
minHeatLoss(end)
138+
```
139+
Notice how minHeatLoss is always updated to the minimum of the state we're visiting from plus the incremental heatloss of the new state we're adding to the queue.
140+
141+
### Part 1
142+
143+
Now we need to model our state transformation restrictions for Part 1. We can typically move straight, left, and right, but we need to make sure our streak straight streak never exceeds 3:
144+
145+
```scala
146+
// Inside case class State:
147+
def nextStates: List[State] =
148+
List(straight, turnLeft, turnRight).filter: s =>
149+
inBounds(s.pos) && s.streak <= 3
150+
```
151+
152+
This will only ever filter out the forward movement, since moving to the left or right resets the streak to 1.
153+
154+
### Part 2
155+
156+
Part 2 is similar, but our streak limit increases to 10.
157+
Furthermore, while the streak is less than four, only a forward movement is possible:
158+
159+
```scala
160+
// inside case class State:
161+
def nextStates2: List[State] =
162+
if streak < 4 then List(straight)
163+
else List(straight, turnLeft, turnRight).filter: s =>
164+
inBounds(s.pos) && s.streak <= 10
165+
```
166+
167+
## Final Code
168+
169+
```scala
170+
import locations.Directory.currentDir
171+
import inputs.Input.loadFileSync
172+
173+
@main def part1: Unit =
174+
println(s"The solution is ${search(_.nextStates)}")
175+
176+
@main def part2: Unit =
177+
println(s"The solution is ${search(_.nextStates2)}")
178+
179+
def loadInput(): Vector[Vector[Int]] = Vector.from:
180+
val file = loadFileSync(s"$currentDir/../input/day17")
181+
for line <- file.split("\n")
182+
yield line.map(_.asDigit).toVector
183+
184+
enum Dir:
185+
case N, S, E, W
186+
187+
def turnRight = this match
188+
case Dir.N => E
189+
case Dir.E => S
190+
case Dir.S => W
191+
case Dir.W => N
192+
193+
def turnLeft = this match
194+
case Dir.N => W
195+
case Dir.W => S
196+
case Dir.S => E
197+
case Dir.E => N
198+
199+
val grid = loadInput()
200+
201+
val xRange = grid.head.indices
202+
val yRange = grid.indices
203+
204+
case class Point(x: Int, y: Int):
205+
def move(dir: Dir) = dir match
206+
case Dir.N => copy(y = y - 1)
207+
case Dir.S => copy(y = y + 1)
208+
case Dir.E => copy(x = x + 1)
209+
case Dir.W => copy(x = x - 1)
210+
211+
def inBounds(p: Point) =
212+
xRange.contains(p.x) && yRange.contains(p.y)
213+
214+
def heatLoss(p: Point) =
215+
if inBounds(p) then grid(p.y)(p.x) else 0
216+
217+
case class State(pos: Point, dir: Dir, streak: Int):
218+
def straight: State =
219+
val newPos = pos.move(dir)
220+
State(pos.move(dir), dir, streak + 1)
221+
222+
def turnLeft: State =
223+
val newDir = dir.turnLeft
224+
val newPos = pos.move(newDir)
225+
State(newPos, newDir, 1)
226+
227+
def turnRight: State =
228+
val newDir = dir.turnRight
229+
val newPos = pos.move(newDir)
230+
State(newPoss, newDir, 1)
231+
232+
def nextStates: List[State] =
233+
List(straight, turnLeft, turnRight).filter: s =>
234+
inBounds(s.pos) && s.streak <= 3
235+
236+
def nextStates2: List[State] =
237+
if streak < 4 then List(straight)
238+
else List(straight, turnLeft, turnRight).filter: s =>
239+
inBounds(s.pos) && s.streak <= 10
240+
241+
def search(next: State => List[State]): Int =
242+
import collection.mutable.{PriorityQueue, Map}
243+
244+
val minHeatLoss = Map.empty[State, Int]
245+
246+
given Ordering[State] = Ordering.by(minHeatLoss)
247+
val pq = PriorityQueue.empty[State].reverse
248+
249+
var visiting = State(Point(0, 0), Dir.E, 0)
250+
val minHeatLoss(visiting) = 0
251+
252+
val end = Point(xRange.max, yRange.max)
253+
while visiting.pos != end do
254+
val states = next(visiting).filterNot(minHeatLoss.contains)
255+
states.foreach: s =>
256+
minHeatLoss(s) = minHeatLoss(visiting) + heatLoss(s)
257+
pq.enqueue(s)
258+
visiting = pq.dequeue()
259+
260+
minHeatLoss(end)
261+
```
262+
263+
### Run it in the browser
264+
265+
#### Part 1
266+
267+
<Solver puzzle="day17-part1" year="2023"/>
268+
269+
#### Part 2
270+
271+
<Solver puzzle="day17-part2" year="2023"/>
272+
9273
## Solutions from the community
10274

275+
- [Solution](https://github.com/stewSquared/advent-of-code/blob/master/src/main/scala/2021/Day17.worksheet.sc) by [stewSquared](https://github.com/stewSquared)
11276
- [Solution](https://github.com/merlinorg/aoc2023/blob/main/src/main/scala/Day17.scala) by [merlin](https://github.com/merlinorg/)
12277
- [Solution](https://github.com/xRuiAlves/advent-of-code-2023/blob/main/Day17.scala) by [Rui Alves](https://github.com/xRuiAlves/)
13278

0 commit comments

Comments
 (0)