Solution for 2023, day 17

Author: lucianoq

2023/17/Makefile

@@ -0,0 +1,17 @@
+main1:
+go build -o main1 main1.go common.go priority_queue.go
+
+main2:
+go build -o main2 main2.go common.go priority_queue.go
+
+.PHONY: run1 run2 clean
+
+run1: main1
+./main1 <input
+
+run2: main2
+./main2 <input
+
+clean:
+rm -f main1 main2
+

2023/17/common.go

@@ -0,0 +1,140 @@
+package main
+
+import (
+"bufio"
+"os"
+)
+
+type Direction uint8
+
+const (
+N Direction = iota
+E
+S
+W
+)
+
+type P struct{ x, y int }
+
+var delta = map[Direction]P{
+N: {-1, 0},
+E: {0, 1},
+S: {1, 0},
+W: {0, -1},
+}
+
+func (p P) Step(dir Direction) P {
+return P{p.x + delta[dir].x, p.y + delta[dir].y}
+}
+
+type Grid struct {
+Heat [][]int
+Size int
+}
+
+func (g Grid) Contains(p P) bool {
+return p.x >= 0 && p.x < g.Size && p.y >= 0 && p.y < g.Size
+}
+
+func (g Grid) Goal(p P) bool {
+return p.x == g.Size-1 && p.y == g.Size-1
+}
+
+func (g Grid) HeatLoss(p P) int {
+return g.Heat[p.x][p.y]
+}
+
+func parse() Grid {
+scanner := bufio.NewScanner(os.Stdin)
+
+g := Grid{}
+
+for scanner.Scan() {
+line := scanner.Text()
+var row []int
+for c := 0; c < len(line); c++ {
+row = append(row, int(line[c]-'0'))
+}
+g.Heat = append(g.Heat, row)
+}
+g.Size = len(g.Heat)
+return g
+}
+
+func PossibleDirections(curr Direction, streak, minSteps, maxSteps int) []Direction {
+if streak < minSteps {
+return []Direction{
+curr, // straight
+}
+}
+
+if streak >= maxSteps {
+return []Direction{
+(curr + 1) % 4, // turn right
+(curr + 3) % 4, // turn left
+}
+}
+
+return []Direction{
+(curr + 1) % 4, // turn right
+curr, // straight
+(curr + 3) % 4, // turn left
+}
+}
+
+type Node struct {
+Pos P
+Dir Direction
+Streak int
+}
+
+func Dijkstra(g Grid, minSteps, maxSteps int) int {
+
+// starting nodes
+startNode := Node{P{0, 0}, E, 0}
+startNode2 := Node{P{0, 0}, S, 0}
+visited := map[Node]int{startNode: 0, startNode2: 0}
+
+pq := NewPriorityQueue()
+pq.Insert(startNode, 0)
+pq.Insert(startNode2, 0)
+
+for pq.Len() > 0 {
+currentNode, currentHeatLoss := pq.PopMin()
+
+if g.Goal(currentNode.Pos) {
+return currentHeatLoss
+}
+
+for _, nextDir := range PossibleDirections(currentNode.Dir, currentNode.Streak, minSteps, maxSteps) {
+
+nextStreak := 1
+if nextDir == currentNode.Dir {
+nextStreak = currentNode.Streak + 1
+}
+
+nextPos := currentNode.Pos.Step(nextDir)
+
+// ignore points out of bound
+if !g.Contains(nextPos) {
+continue
+}
+
+nextNode := Node{
+Pos: nextPos,
+Dir: nextDir,
+Streak: nextStreak,
+}
+nextHeatLoss := currentHeatLoss + g.HeatLoss(nextPos)
+
+if oldHeatLoss, ok := visited[nextNode]; ok && oldHeatLoss <= nextHeatLoss {
+continue
+}
+
+visited[nextNode] = nextHeatLoss
+pq.Insert(nextNode, nextHeatLoss)
+}
+}
+
+return 0
+}

2023/17/main1.go

@@ -0,0 +1,9 @@
+package main
+
+import "fmt"
+
+func main() {
+g := parse()
+
+fmt.Println(Dijkstra(g, 1, 3))
+}

2023/17/main2.go

@@ -0,0 +1,9 @@
+package main
+
+import "fmt"
+
+func main() {
+g := parse()
+
+fmt.Println(Dijkstra(g, 4, 10))
+}

2023/17/priority_queue.go

@@ -0,0 +1,56 @@
+package main
+
+import "container/heap"
+
+type item struct {
+value Node
+priority int
+}
+
+type PriorityQueue []*item
+
+func (pq PriorityQueue) Len() int {
+return len(pq)
+}
+
+func (pq PriorityQueue) Less(i, j int) bool {
+return pq[i].priority < pq[j].priority
+}
+
+func (pq PriorityQueue) Swap(i, j int) {
+pq[i], pq[j] = pq[j], pq[i]
+}
+
+func (pq *PriorityQueue) Push(x interface{}) {
+it := x.(*item)
+*pq = append(*pq, it)
+}
+
+func (pq *PriorityQueue) Pop() interface{} {
+old := *pq
+n := len(old)
+it := old[n-1]
+old[n-1] = nil
+*pq = old[0 : n-1]
+return it
+}
+
+func NewPriorityQueue() *PriorityQueue {
+pq := make(PriorityQueue, 0)
+heap.Init(&pq)
+return &pq
+}
+
+// typed wrappers around heap package
+
+func (pq *PriorityQueue) Insert(node Node, priority int) {
+heap.Push(pq, &item{
+value: node,
+priority: priority,
+})
+}
+
+func (pq *PriorityQueue) PopMin() (Node, int) {
+it := heap.Pop(pq).(*item)
+return it.value, it.priority
+}