chore(day17): implement fibHeap for faster priority queue

aoc_test.go

@@ -85,36 +85,35 @@ func TestPriorityQueue(t *testing.T) {
 	is := is.New(t)
 
 	type elem [2]int
-	less := func(a, b elem) bool {
-		return a[0] < b[0]
+	less := func(b, a *elem) bool {
+		return (*a)[0] < (*b)[0]
 	}
 
 	pq := aoc.PriorityQueue(less)
 
-	pq.Enqueue(elem{1, 4})
-	pq.Enqueue(elem{3, 2})
-	pq.Enqueue(elem{2, 3})
-	pq.Enqueue(elem{4, 1})
+	pq.Insert(&elem{1, 4})
+	pq.Insert(&elem{3, 2})
+	pq.Insert(&elem{2, 3})
+	pq.Insert(&elem{4, 1})
 
-	v, ok := pq.Dequeue()
-	is.True(ok)
-	is.Equal(v, elem{4, 1})
+	v := pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{4, 1})
 
-	v, ok = pq.Dequeue()
-	is.True(ok)
-	is.Equal(v, elem{3, 2})
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{3, 2})
 
-	v, ok = pq.Dequeue()
-	is.True(ok)
-	is.Equal(v, elem{2, 3})
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{2, 3})
 
-	v, ok = pq.Dequeue()
-	is.True(ok)
-	is.Equal(v, elem{1, 4})
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{1, 4})
 
-	v, ok = pq.Dequeue()
-	is.True(!ok)
-	is.Equal(v, elem{})
+	v = pq.ExtractMin()
+	is.True(v == nil)
 }
 
 func TestSet(t *testing.T) {
@@ -140,7 +139,7 @@ func ExamplePriorityQueue() {
 		pt    int
 		score int
 	}
-	less := func(a, b memo) bool { return b.score < a.score }
+	less := func(a, b *memo) bool { return a.score < b.score }
 
 	adj := map[int][][2]int{
 		0: {{1, 2}, {2, 6}},
@@ -156,10 +155,10 @@ func ExamplePriorityQueue() {
 	dist := aoc.DefaultMap[int](int(^uint(0) >> 1))
 
 	dist.Set(0, 0)
-	pq.Enqueue(memo{0, 0})
+	pq.Insert(&memo{0, 0})
 
 	for !pq.IsEmpty() {
-		m, _ := pq.Dequeue()
+		m := pq.ExtractMin()
 
 		u := m.pt
 		if visited.Has(u) {
@@ -175,7 +174,7 @@ func ExamplePriorityQueue() {
 
 			if !visited.Has(v) && du+w < dv {
 				dist.Set(v, du+w)
-				pq.Enqueue(memo{v, du + w})
+				pq.Insert(&memo{v, du + w})
 			}
 		}
 	}
@@ -199,14 +198,14 @@ func ExamplePriorityQueue() {
 func TestStack(t *testing.T) {
 	is := is.New(t)
 
-	s := aoc.Stack(1,2,3,4)
+	s := aoc.Stack(1, 2, 3, 4)
 	is.True(!s.IsEmpty())
 	is.Equal(s.Pop(), 4)
 	is.Equal(s.Pop(), 3)
 	is.Equal(s.Pop(), 2)
 	is.Equal(s.Pop(), 1)
 	is.True(s.IsEmpty())
-	s.Push(4,3,2,1)
+	s.Push(4, 3, 2, 1)
 	is.True(!s.IsEmpty())
 	is.Equal(s.Pop(), 1)
 	is.Equal(s.Pop(), 2)
@@ -230,7 +229,125 @@ func TestGraph(t *testing.T) {
 		9: {6, 0, 8},
 	}
 
-	g := aoc.Graph(aoc.WithAdjacencyList[int,int](adjacencyList))
-	is.Equal(g.Neighbors(1), []int{2,4})
+	g := aoc.Graph(aoc.WithAdjacencyList[int, int](adjacencyList))
+	is.Equal(g.Neighbors(1), []int{2, 4})
 	is.Equal(map[int][]int(g.AdjacencyList()), adjacencyList)
 }
+
+func ExampleFibHeap() {
+	type memo struct {
+		pt    int
+		score int
+	}
+	less := func(a, b *memo) bool { return (*a).score < (*b).score }
+
+	adj := map[int][][2]int{
+		0: {{1, 2}, {2, 6}},
+		1: {{3, 5}},
+		2: {{3, 8}},
+		3: {{4, 10}, {5, 15}},
+		4: {{6, 2}},
+		5: {{6, 6}},
+	}
+
+	pq := aoc.FibHeap(less)
+	visited := aoc.Set([]int{}...)
+	dist := aoc.DefaultMap[int](int(^uint(0) >> 1))
+
+	dist.Set(0, 0)
+	pq.Insert(&memo{0, 0})
+
+	for !pq.IsEmpty() {
+		m := pq.ExtractMin()
+
+		u := m.pt
+		if visited.Has(u) {
+			continue
+		}
+		visited.Add(u)
+
+		du, _ := dist.Get(u)
+
+		for _, edge := range adj[u] {
+			v, w := edge[0], edge[1]
+			dv, _ := dist.Get(v)
+
+			if !visited.Has(v) && du+w < dv {
+				dist.Set(v, du+w)
+				pq.Insert(&memo{v, du + w})
+			}
+		}
+	}
+
+	items := dist.Items()
+	sort.Slice(items, func(i, j int) bool { return items[i].K < items[j].K })
+	for _, v := range items {
+		fmt.Printf("point %d is %d steps away.\n", v.K, v.V)
+	}
+
+	// Output:
+	// point 0 is 0 steps away.
+	// point 1 is 2 steps away.
+	// point 2 is 6 steps away.
+	// point 3 is 7 steps away.
+	// point 4 is 17 steps away.
+	// point 5 is 22 steps away.
+	// point 6 is 19 steps away.
+}
+
+func TestFibHeap(t *testing.T) {
+	is := is.New(t)
+
+	type elem [2]int
+	less := func(a, b *elem) bool {
+		return (*a)[0] < (*b)[0]
+	}
+
+	pq := aoc.FibHeap(less)
+
+	pq.Insert(&elem{1, 4})
+	pq.Insert(&elem{3, 2})
+	pq.Insert(&elem{2, 3})
+	pq.Insert(&elem{4, 1})
+
+	v := pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{1, 4})
+
+	pq.Insert(&elem{5, 8})
+	pq.Insert(&elem{6, 7})
+	pq.Insert(&elem{7, 6})
+	pq.Insert(&elem{8, 5})
+
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{2, 3})
+
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{3, 2})
+
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{4, 1})
+
+	v = pq.ExtractMin()
+	is.True(v != nil)
+	is.Equal(v, &elem{5, 8})
+
+	m := aoc.FibHeap(less)
+	m.Insert(&elem{12, 9})
+	m.Insert(&elem{11, 10})
+	m.Insert(&elem{10, 11})
+	m.Insert(&elem{9, 12})
+
+	pq.Merge(m)
+
+	var keys []int
+	for !pq.IsEmpty() {
+		v := pq.ExtractMin()
+		fmt.Println(v)
+		keys = append(keys, v[0])
+	}
+	is.Equal(keys, []int{6, 7, 8, 9, 10, 11, 12})
+}

day17/main.go

@@ -131,9 +131,9 @@ func (g *graph) Cost(a, b position) int16 {
 }
 
 // Potential calculates distance to target
-func (g *graph) Potential(a position) int16 {
-	return aoc.ManhattanDistance(a.loc, g.target)
-}
+// func (g *graph) Potential(a position) int16 {
+// 	return aoc.ManhattanDistance(a.loc, g.target)
+// }
 
 // Target returns true when target reached. receives node and cost.
 func (g *graph) Target(a position, c int16) bool {
@@ -169,6 +169,7 @@ func search(m Map, minSteps, maxSteps int8, seenFn func(position) position) int
 	target := Point{rows - 1, cols - 1}
 
 	g := graph{min: minSteps, max: maxSteps, m: m, target: target, seenFn: seenFn}
+
 	cost, path, closed := aoc.FindPath[int16, position](&g, position{loc: start}, position{loc: target})
 
 	log("total map reads = ", g.reads, "cost = ", cost)
@@ -190,30 +191,33 @@ func printGraph(m Map, path []position, closed map[position]int16, seenFn func(a
 	}
 
 	for r, row := range m {
-		if r == 0 {
-			for c := range row {
-				if c == 0 {
-					fmt.Print("     ")
-				}
-				fmt.Printf("% 5d", c)
-			}
-			fmt.Println("")
-		}
+		// if r == 0 {
+		// 	for c := range row {
+		// 		if c == 0 {
+		// 			fmt.Print("     ")
+		// 		}
+		// 		fmt.Printf("% 5d", c)
+		// 	}
+		// 	fmt.Println("")
+		// }
 		for c := range row {
-			if c == 0 {
-				fmt.Printf("% 5d", r)
-			}
+			// if c == 0 {
+			// 	fmt.Printf("% 5d", r)
+			// }
 
 			if pt, ok := pts[Point{int16(r), int16(c)}]; ok {
 				if seenFn != nil {
 					pt = seenFn(pt)
 				}
-				fmt.Printf("% 5d", closed[pt])
+				_ = pt
+				// fmt.Printf("% 5d", closed[pt])
+				fmt.Print("*")
 
 				continue
 			}
 
-			fmt.Print(" ....")
+			// fmt.Print(" ....")
+			fmt.Print(" ")
 		}
 		fmt.Println("")
 	}

day19/main.go

@@ -186,8 +186,8 @@ func solveWorkflow(parts []part, workflows map[string][]rule) int {
 
 func solveRanges(workflows map[string][]rule) uint {
 
-	pq := aoc.PriorityQueue(func(a, b queue) bool { return false })
-	pq.Enqueue(queue{
+	pq := aoc.PriorityQueue(func(a, b *queue) bool { return false })
+	pq.Insert(&queue{
 		"in",
 		block{
 			ranger{1, 4000},
@@ -200,9 +200,9 @@ func solveRanges(workflows map[string][]rule) uint {
 	// var rejected []block
 
 	for !pq.IsEmpty() {
-		current, _ := pq.Dequeue()
+		current := pq.ExtractMin()
 		for _, rule := range workflows[current.name] {
-			next := queue{name: rule.queue, block: current.block}
+			next := &queue{name: rule.queue, block: current.block}
 
 			switch rule.match {
 			case "x":
@@ -223,14 +223,14 @@ func solveRanges(workflows map[string][]rule) uint {
 				accepted = append(accepted, next.block)
 
 			default:
-				pq.Enqueue(next)
+				pq.Insert(next)
 			}
 		}
 	}
 
 	var sum uint
 	for _, a := range accepted {
-		sum += uint((a.x[1]-a.x[0]+1) * (a.m[1]-a.m[0]+1) * (a.a[1]-a.a[0]+1) * (a.s[1]-a.s[0]+1))
+		sum += uint((a.x[1] - a.x[0] + 1) * (a.m[1] - a.m[0] + 1) * (a.a[1] - a.a[0] + 1) * (a.s[1] - a.s[0] + 1))
 	}
 
 	return sum

runner.go

@@ -2,26 +2,70 @@ package aoc
 
 import (
 	"bufio"
+	"flag"
 	"fmt"
+	"log"
 	"os"
 	"path/filepath"
+	"runtime"
+	"runtime/pprof"
 	"strings"
 	"time"
 )
 
+var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to `file`")
+var memprofile = flag.String("memprofile", "", "write memory profile to `file`")
+
 func Runner[R any, F func(*bufio.Scanner) (R, error)](run F) (R, error) {
-	if len(os.Args) != 2 {
+	if len(os.Args) < 2 {
 		Log("Usage:", filepath.Base(os.Args[0]), "FILE")
 		os.Exit(22)
 	}
 
-	input, err := os.Open(os.Args[1])
+	inputFilename := os.Args[1]
+	os.Args = append(os.Args[:1], os.Args[2:]...)
+
+	flag.Parse()
+	Log(cpuprofile, memprofile, *cpuprofile, *memprofile)
+	if *cpuprofile != "" {
+		Log("enabled cpu profile")
+		f, err := os.Create(*cpuprofile)
+		if err != nil {
+			log.Fatal("could not create CPU profile: ", err)
+		}
+		defer f.Close() // error handling omitted for example
+		Log("write cpu profile to", f.Name())
+		if err := pprof.StartCPUProfile(f); err != nil {
+			log.Fatal("could not start CPU profile: ", err)
+		}
+		defer pprof.StopCPUProfile()
+	}
+
+	if *memprofile != "" {
+		Log("enabled mem profile")
+		defer func() {
+			f, err := os.Create(*memprofile)
+			if err != nil {
+				log.Fatal("could not create memory profile: ", err)
+			}
+			Log("write mem profile to", f.Name())
+			defer f.Close() // error handling omitted for example
+			runtime.GC()    // get up-to-date statistics
+			if err := pprof.WriteHeapProfile(f); err != nil {
+				log.Fatal("could not write memory profile: ", err)
+			}
+		}()
+	}
+
+
+	input, err := os.Open(inputFilename)
 	if err != nil {
 		Log(err)
 		os.Exit(1)
 	}
 
 	scan := bufio.NewScanner(input)
+
 	return run(scan)
 }
 

search.go

@@ -1,12 +1,13 @@
 package aoc
 
 import (
+	"math/bits"
 	"sort"
 )
 
 type priorityQueue[T any] struct {
-	elems        []T
-	less         func(a, b T) bool
+	elems        []*T
+	less         func(a, b *T) bool
 	maxDepth     int
 	totalEnqueue int
 	totalDequeue int
@@ -16,10 +17,10 @@ type priorityQueue[T any] struct {
 // less is the function for sorting. reverse a and b to reverse the sort.
 // T is the item
 // U is a slice of T
-func PriorityQueue[T any](less func(a, b T) bool) *priorityQueue[T] {
+func PriorityQueue[T any](less func(a, b *T) bool) *priorityQueue[T] {
 	return &priorityQueue[T]{less: less}
 }
-func (pq *priorityQueue[T]) Enqueue(elem T) {
+func (pq *priorityQueue[T]) Insert(elem *T) {
 	pq.totalEnqueue++
 
 	pq.elems = append(pq.elems, elem)
@@ -28,17 +29,17 @@ func (pq *priorityQueue[T]) Enqueue(elem T) {
 func (pq *priorityQueue[T]) IsEmpty() bool {
 	return len(pq.elems) == 0
 }
-func (pq *priorityQueue[T]) Dequeue() (T, bool) {
+func (pq *priorityQueue[T]) ExtractMin() *T {
 	pq.totalDequeue++
 
-	var elem T
+	var elem *T
 	if pq.IsEmpty() {
-		return elem, false
+		return elem
 	}
 
-	sort.Slice(pq.elems, func(i, j int) bool { return pq.less(pq.elems[i], pq.elems[j]) })
+	sort.Slice(pq.elems, func(i, j int) bool { return pq.less(pq.elems[j], pq.elems[i]) })
 	pq.elems, elem = pq.elems[:len(pq.elems)-1], pq.elems[len(pq.elems)-1]
-	return elem, true
+	return elem
 }
 
 type stack[T any] []T
@@ -129,31 +130,22 @@ func FindPath[C integer, N comparable](g pather[C, N], start, end N) (C, []N, ma
 		return path
 	}
 
-	less := func(a, b node) bool {
-		return  b.cost+b.potential < a.cost+a.potential
+	less := func(a, b *node) bool {
+		return a.cost+a.potential < b.cost+b.potential
 	}
 
 	closed := make(map[N]C)
-	open := PriorityQueue(less)
+	open := FibHeap(less)
 
-	open.Enqueue(node{position: start, potential: potentialFn(start)})
+	open.Insert(&node{position: start, potential: potentialFn(start)})
 	closed[start] = zero
 
-	// defer func() {
-	// 	Log(
-	// 		"queue max depth = ", open.maxDepth, 
-	// 		"total enqueue = ", open.totalEnqueue, 
-	// 		"total dequeue = ", open.totalDequeue,
-	// 		"total closed = ", len(closed),
-	// 	)
-	// }()
-
 	for !open.IsEmpty() {
-		current, _ := open.Dequeue()
+		current := open.ExtractMin()
 		for _, nb := range g.Neighbors(current.position) {
-			next := node{
+			next := &node{
 				position:  nb,
-				parent:    &current,
+				parent:    current,
 				cost:      g.Cost(current.position, nb) + current.cost,
 				potential: potentialFn(nb),
 			}
@@ -161,14 +153,120 @@ func FindPath[C integer, N comparable](g pather[C, N], start, end N) (C, []N, ma
 			seen := seenFn(nb)
 			cost, ok := closed[seen]
 			if !ok || next.cost < cost {
-				open.Enqueue(next)
+				open.Insert(next)
 				closed[seen] = next.cost
 			}
 
 			if next.potential == zero && g.Target(next.position, next.cost) {
-				return next.cost, newPath(&next), closed
+				return next.cost, newPath(next), closed
 			}
 		}
 	}
 	return zero, nil, closed
 }
+
+type fibTree[T any] struct {
+	value *T
+	parent *fibTree[T]
+	child []*fibTree[T]
+}
+
+func (t *fibTree[T]) addAtEnd(n *fibTree[T]) {
+	n.parent = t
+	t.child = append(t.child, n)
+}
+
+type fibHeap[T any] struct {
+	trees []*fibTree[T]
+	least *fibTree[T]
+	count uint
+	less  func(a, b *T) bool
+}
+
+func FibHeap[T any](less func(a, b *T) bool) *fibHeap[T] {
+	return &fibHeap[T]{less: less}
+}
+
+func (h *fibHeap[T]) GetMin() *T {
+	return h.least.value
+}
+
+func (h *fibHeap[T]) IsEmpty() bool { return h.least == nil }
+
+func (h *fibHeap[T]) Insert(v *T) {
+	ntree := &fibTree[T]{value: v}
+	h.trees = append(h.trees, ntree)
+	if h.least == nil || h.less(v, h.least.value) {
+		h.least = ntree
+	}
+	h.count++
+}
+
+func (h *fibHeap[T]) ExtractMin() *T {
+	smallest := h.least
+	if smallest != nil {
+		// Remove smallest from root trees.
+		for i := range h.trees {
+			pos := h.trees[i]
+			if pos == smallest {
+				h.trees[i] = h.trees[len(h.trees)-1]
+				h.trees = h.trees[:len(h.trees)-1]
+				break
+			}
+		}
+
+		// Add children to root
+		h.trees = append(h.trees, smallest.child...)
+		smallest.child = smallest.child[:0]
+
+		h.least = nil
+		if len(h.trees) > 0 {
+			h.consolidate()
+		}
+
+		h.count--
+		return smallest.value
+	}
+	return nil
+}
+
+func (h *fibHeap[T]) consolidate() {
+	aux := make([]*fibTree[T], bits.Len(h.count))
+	for _, x := range h.trees {
+		order := len(x.child)
+
+		// consolidate the larger roots under smaller roots of same order until we have at most one tree per order.
+		for aux[order] != nil {
+			y := aux[order]
+			if h.less(y.value, x.value) {
+				x, y = y, x
+			}
+			x.addAtEnd(y)
+			aux[order] = nil
+			order++
+		}
+		aux[order] = x
+	}
+
+	h.trees = h.trees[:0]
+	// move ordered trees to root and find least node.
+	for _, k := range aux {
+		if k != nil {
+			k.parent = nil
+			h.trees = append(h.trees, k)
+			if h.least == nil || h.less(k.value, h.least.value) {
+				h.least = k
+			}
+		}
+	}
+}
+
+func (h *fibHeap[T]) Merge(a *fibHeap[T]) {
+	h.trees = append(h.trees, a.trees...)
+	h.count += a.count
+	h.consolidate()
+}
+
+// func (h *fibHeap[T]) Find(n *T) *fibTree[T] {
+	
+// }