day17/main.go

@@ -4,7 +4,6 @@ import (
 	"bufio"
 	_ "embed"
 	"fmt"
-	"sort"
 
 	aoc "go.sour.is/advent-of-code"
 )
@@ -22,193 +21,39 @@ func (r result) String() string { return fmt.Sprintf("%#v", r) }
 
 func run(scan *bufio.Scanner) (*result, error) {
 	var m Map
+	var pq aoc.PriorityQueue[int, uint]
 
 	for scan.Scan() {
 		text := scan.Text()
 		m = append(m, []rune(text))
 	}
 
-	result := result{}
+	rows := len(m)
-	// result.valuePT1 = search(m, 1, 3)
+	cols := len(m[0])
-	result.valuePT2 = search(m, 4, 10)
 
-	return &result, nil
+	END := [2]int{rows-1, cols-1}
+
+	return &result{}, nil
 }
 
 var (
-	ZERO = point{0, 0}
+	ZERO = [2]int{0, 0}
 
-	UP = point{-1, 0}
+	UP = [2]int{-1, 0}
-	DN = point{1, 0}
+	DN = [2]int{1, 0}
-	LF = point{0, -1}
+	LF = [2]int{0, -1}
-	RT = point{0, 1}
+	RT = [2]int{0, 1}
-
-	INF = int(^uint(0) >> 1)
 )
 
 type Map [][]rune
 
-func (m *Map) Get(p point) (point, int, bool) {
+func (m *Map) Get(p [2]int) rune {
-	if !m.Valid(p) {
+	if p[0] < 0 || p[0] >= len((*m)) {
-		return [2]int{0, 0}, 0, false
+		return 0
+	}
+	if p[1] < 0 || p[1] >= len((*m)[0]) {
+		return 0
 	}
 
-	return p, int((*m)[p[0]][p[1]] - '0'), true
+	return (*m)[p[0]][p[1]]
 }
-func (m *Map) GetNeighbor(p point, d point) (point, int, bool) {
-	return m.Get(p.add(d))
-}
-func (m *Map) Size() (int, int) {
-	if m == nil || len(*m) == 0 {
-		return 0, 0
-	}
-	return len(*m), len((*m)[0])
-}
-func (m *Map) Neighbors(p point) []point {
-	var lis []point
-	for _, d := range []point{UP, DN, LF, RT} {
-		if p, _, ok := m.GetNeighbor(p, d); ok {
-			lis = append(lis, p)
-		}
-	}
-	return lis
-}
-func (m *Map) NeighborDirections(p point) []point {
-	var lis []point
-	for _, d := range []point{UP, DN, LF, RT} {
-		if m.Valid(p.add(d)) {
-			lis = append(lis, d)
-		}
-	}
-	return lis
-}
-func (m *Map) Valid(p point) bool {
-	rows, cols := m.Size()
-	return p[0] >= 0 && p[0] < rows && p[1] >= 0 && p[1] < cols
-}
-
-type memo struct {
-	h int
-	s int
-	p point
-	d point
-}
-
-func (memo) sort(a, b memo) bool {
-	if a.h != b.h {
-		return a.h < b.h
-	}
-
-	if a.s != b.s {
-		return a.s < b.s
-	}
-
-	if a.p != b.p {
-		return a.p.less(b.p)
-	}
-
-	return a.d.less(b.d)
-}
-
-type priorityQueue[T any, U []T] struct {
-	elems U
-	sort  func(a, b T) bool
-}
-
-func PriorityQueue[T any, U []T](sort func(a, b T) bool) *priorityQueue[T, U] {
-	return &priorityQueue[T, U]{sort: sort}
-}
-func (pq *priorityQueue[T, U]) Enqueue(elem T) {
-	pq.elems = append(pq.elems, elem)
-	sort.Slice(pq.elems, func(i, j int) bool { return pq.sort(pq.elems[i], pq.elems[j]) })
-}
-func (pq *priorityQueue[T, I]) IsEmpty() bool {
-	return len(pq.elems) == 0
-}
-func (pq *priorityQueue[T, I]) Dequeue() (T, bool) {
-	var elem T
-	if pq.IsEmpty() {
-		return elem, false
-	}
-
-	elem, pq.elems = pq.elems[0], pq.elems[1:]
-	return elem, true
-}
-
-func heuristic(m Map, p point) int {
-	rows, cols := m.Size()
-	return rows - p[0] + cols - p[1]
-}
-
-func search(m Map, minSize, maxSize int) int {
-	rows, cols := m.Size()
-	END := point{rows - 1, cols - 1}
-
-	visited := make(map[vector]int)
-	pq := PriorityQueue(memo{}.sort)
-	pq.Enqueue(memo{h: heuristic(m, point{0, 0}), p: point{0, 0}, d: DN})
-	
-	for !pq.IsEmpty() {
-		mem, _ := pq.Dequeue()
-		fmt.Println(mem)
-		if mem.h > dmap(visited, vector{mem.p[0], mem.p[1], mem.d[0], mem.d[1]}, INF) {
-			continue
-		}
-
-		if mem.p == END {
-			return mem.s
-		}
-
-		for _, nd := range m.NeighborDirections(mem.p) {
-			if nd[0] == 0 && mem.d == RT || nd[1] == 0 && mem.d == DN {
-				continue
-			}
-
-			dscore := 0
-
-			for _, size := range irange(1, maxSize+1) {
-				np := mem.p.add(nd.scale(size))
-				_, s, ok := m.Get(np)
-
-				if !ok {
-					break
-				}
-
-				dscore += s
-				pscore := mem.s + dscore
-
-				nh := heuristic(m, np) + pscore
-				vec := vector{np[0], np[1], nd[0], nd[1]}
-
-				if size >= minSize && nh < dmap(visited, vec, INF) {
-					pq.Enqueue(memo{nh, pscore, np, nd})
-					visited[vec] = nh
-				}
-			}
-		}
-	}
-
-	return 0
-}
-
-func dmap[K comparable, V any](m map[K]V, k K, d V) V {
-	if v, ok := m[k]; ok {
-		return v
-	}
-	return d
-}
-func irange(a, b int) []int {
-	lis := make([]int, b-a)
-	for i := range lis {
-		lis[i] = i + a
-	}
-	return lis
-}
-
-type point [2]int
-
-func (p point) add(a point) point { return point{p[0] + a[0], p[1] + a[1]} }
-func (p point) scale(m int) point { return point{p[0] * m, p[1] * m} }
-func (p point) less(a point) bool { return p[0] < a[0] || p[1] < a[1] }
-
-type vector [4]int

day17/main_test.go

@@ -25,7 +25,7 @@ func TestExample(t *testing.T) {
 
 	t.Log(result)
 	is.Equal(result.valuePT1, 102)
-	is.Equal(result.valuePT2, 94)
+	is.Equal(result.valuePT2, 0)
 }
 
 func TestSolution(t *testing.T) {
@@ -36,6 +36,6 @@ func TestSolution(t *testing.T) {
 	is.NoErr(err)
 
 	t.Log(result)
-	is.Equal(result.valuePT1, 843)
+	is.Equal(result.valuePT1, 0)
-	is.Equal(result.valuePT2, 1017)
+	is.Equal(result.valuePT2, 0)
 }

tools.go

@@ -51,10 +51,10 @@ func Reverse[T any](arr []T) []T {
 	return arr
 }
 
-type uinteger interface {
+type uinteger interface{
 	uint | uint8 | uint16 | uint32 | uint64
 }
-type sinteger interface {
+type sinteger interface{
 	int | int8 | int16 | int32 | int64
 }
 type integer interface {
@@ -342,22 +342,21 @@ type Vertex[V comparable, I integer] struct {
 type graph[V comparable, I uinteger] struct {
 	adj map[V][]Vertex[V, I]
 }
-
+func Graph[V comparable, I uinteger](size int) *graph[V,I] {
-func Graph[V comparable, I uinteger](size int) *graph[V, I] {
+	return &graph[V,I]{
-	return &graph[V, I]{
+		adj:  make(map[V][]Vertex[V,I], size),
-		adj: make(map[V][]Vertex[V, I], size),
 	}
 }
-func (g *graph[V, I]) AddEdge(u, v V, w I) {
+func (g *graph[V,I]) AddEdge(u, v V, w I) {
 	g.adj[u] = append(g.adj[u], Vertex[V, I]{to: v, score: w})
 	g.adj[v] = append(g.adj[v], Vertex[V, I]{to: u, score: w})
 }
-func (g *graph[V, I]) Dijkstra(m interface{Get()}, src V) map[V]I {
+func (g *graph[V,I]) Dijkstra(src V) {
-	pq := PriorityQueue[V, I]{}
+	pq := PriorityQueue[V,I]{}
 	dist := make(map[V]I, len(g.adj))
 	visited := make(map[V]bool, len(g.adj))
 	var INF I
-	INF = ^INF
+	INF = ^INF>>1
 
 	pq.Enqueue(src, 0)
 	dist[src] = 0
@@ -374,22 +373,23 @@ func (g *graph[V, I]) Dijkstra(m interface{Get()}, src V) map[V]I {
 			_, ok := visited[v.to]
 			var du, dv I
 			if d, inf := dist[u]; !inf {
-				du = INF
+				du=INF
 			} else {
 				du = d
 			}
 			if d, inf := dist[v.to]; !inf {
-				dv = INF
+				dv=INF
 			} else {
 				dv = d
-			}
+			} 
 
-			if !ok && du+v.score < dv {
+			if !ok && du + v.score < dv {
 				dist[v.to] = du + v.score
-				pq.Enqueue(v.to, du+v.score)
+				pq.Enqueue(v.to, du + v.score)
 			}
 		}
 	}
-
+	for v, w := range dist {
-	return dist
+		fmt.Printf("%v, %v\n", v, w)
-}
+	}
+}

tools_test.go

@@ -89,5 +89,5 @@ func TestGraph(t *testing.T) {
 	g.AddEdge(3, 5, 15)
 	g.AddEdge(4, 6, 2)
 	g.AddEdge(5, 6, 6)
-	// g.Dijkstra(0)
+	g.Dijkstra(0)
 }