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
+}