Updated utils, graph, &polyfence. Added xor & minpresses

Author: liamgallear

utils/graph/graph.go

@@ -1,6 +1,10 @@
 package graph
 
-import "image"
+import (
+	"container/heap"
+	"image"
+	"math"
+)
 
 type Queue[T any] []T
 
@@ -92,3 +96,170 @@ func Search(g Graph, s, e image.Point) (res []image.Point) {
 	}
 	return
 }
+
+// PriorityQueueItem represents an item in the priority queue
+type PriorityQueueItem struct {
+	Node     string
+	Distance int
+	Index    int
+}
+
+// PriorityQueue implements heap.Interface for Dijkstra's algorithm
+type PriorityQueue []*PriorityQueueItem
+
+func (pq PriorityQueue) Len() int { return len(pq) }
+
+func (pq PriorityQueue) Less(i, j int) bool {
+	return pq[i].Distance < pq[j].Distance
+}
+
+func (pq PriorityQueue) Swap(i, j int) {
+	pq[i], pq[j] = pq[j], pq[i]
+	pq[i].Index = i
+	pq[j].Index = j
+}
+
+func (pq *PriorityQueue) Push(x interface{}) {
+	n := len(*pq)
+	item := x.(*PriorityQueueItem)
+	item.Index = n
+	*pq = append(*pq, item)
+}
+
+func (pq *PriorityQueue) Pop() interface{} {
+	old := *pq
+	n := len(old)
+	item := old[n-1]
+	old[n-1] = nil
+	item.Index = -1
+	*pq = old[0 : n-1]
+	return item
+}
+
+// Dijkstra finds the shortest path from start to end node
+// graph is a map of node -> list of connected nodes
+// Returns the distance to the end node, or -1 if no path exists
+func Dijkstra(graph map[string][]string, start, end string) int {
+	distances := make(map[string]int)
+
+	// Initialize distances for all nodes in the graph
+	for node := range graph {
+		distances[node] = math.MaxInt32
+	}
+	distances[start] = 0
+
+	// Also ensure end node exists in distances even if it has no outgoing edges
+	if _, exists := distances[end]; !exists {
+		distances[end] = math.MaxInt32
+	}
+
+	pq := make(PriorityQueue, 0)
+	heap.Init(&pq)
+	heap.Push(&pq, &PriorityQueueItem{
+		Node:     start,
+		Distance: 0,
+	})
+
+	visited := make(map[string]bool)
+
+	for pq.Len() > 0 {
+		current := heap.Pop(&pq).(*PriorityQueueItem)
+
+		if current.Node == end {
+			return current.Distance
+		}
+
+		if visited[current.Node] {
+			continue
+		}
+		visited[current.Node] = true
+
+		for _, neighbor := range graph[current.Node] {
+			if visited[neighbor] {
+				continue
+			}
+
+			newDist := current.Distance + 1 // Each edge has weight 1
+
+			if newDist < distances[neighbor] {
+				distances[neighbor] = newDist
+				heap.Push(&pq, &PriorityQueueItem{
+					Node:     neighbor,
+					Distance: newDist,
+				})
+			}
+		}
+	}
+
+	// No path found
+	return -1
+}
+
+// DijkstraWithPath finds the shortest path and returns both distance and the path
+func DijkstraWithPath(graph map[string][]string, start, end string) (int, []string) {
+	distances := make(map[string]int)
+	previous := make(map[string]string)
+
+	// Initialize distances for all nodes in the graph
+	for node := range graph {
+		distances[node] = math.MaxInt32
+	}
+	distances[start] = 0
+
+	// Also ensure end node exists in distances even if it has no outgoing edges
+	if _, exists := distances[end]; !exists {
+		distances[end] = math.MaxInt32
+	}
+
+	pq := make(PriorityQueue, 0)
+	heap.Init(&pq)
+	heap.Push(&pq, &PriorityQueueItem{
+		Node:     start,
+		Distance: 0,
+	})
+
+	visited := make(map[string]bool)
+
+	for pq.Len() > 0 {
+		current := heap.Pop(&pq).(*PriorityQueueItem)
+
+		if current.Node == end {
+			// Reconstruct path
+			path := []string{}
+			node := end
+			for node != "" {
+				path = append([]string{node}, path...)
+				prev, exists := previous[node]
+				if !exists {
+					break
+				}
+				node = prev
+			}
+			return current.Distance, path
+		}
+
+		if visited[current.Node] {
+			continue
+		}
+		visited[current.Node] = true
+
+		for _, neighbor := range graph[current.Node] {
+			if visited[neighbor] {
+				continue
+			}
+
+			newDist := current.Distance + 1
+
+			if newDist < distances[neighbor] {
+				distances[neighbor] = newDist
+				previous[neighbor] = current.Node
+				heap.Push(&pq, &PriorityQueueItem{
+					Node:     neighbor,
+					Distance: newDist,
+				})
+			}
+		}
+	}
+
+	return -1, nil
+}

utils/minpresses/minpresses.go

@@ -0,0 +1,104 @@
+package minpresses
+
+import "sort"
+
+// SolveMinPresses finds the minimum number of button presses to reach target joltages
+func SolveMinPresses(buttonPositions [][]int, targetJoltages []int) (int, bool) {
+	numButtons := len(buttonPositions)
+	numPositions := len(targetJoltages)
+
+	// Sort buttons by number of positions affected
+	type ButtonInfo struct {
+		positions []int
+	}
+
+	buttons := make([]ButtonInfo, numButtons)
+	for i := 0; i < numButtons; i++ {
+		buttons[i] = ButtonInfo{positions: buttonPositions[i]}
+	}
+
+	sort.Slice(buttons, func(i, j int) bool {
+		return len(buttons[i].positions) < len(buttons[j].positions)
+	})
+
+	// Use a fixed-size state for faster hashing (max 10 positions should be enough)
+	type State struct {
+		btnIdx int
+		vals   [10]int
+	}
+
+	memo := make(map[State]int)
+
+	var dp func(btnIdx int, current []int) int
+	dp = func(btnIdx int, current []int) int {
+		if btnIdx >= numButtons {
+			for i := 0; i < numPositions; i++ {
+				if current[i] != targetJoltages[i] {
+					return 1e9
+				}
+			}
+			return 0
+		}
+
+		// Create state
+		var state State
+		state.btnIdx = btnIdx
+		copy(state.vals[:], current)
+
+		if cached, ok := memo[state]; ok {
+			return cached
+		}
+
+		btn := buttons[btnIdx]
+
+		// Calculate max needed
+		maxNeeded := 0
+		for _, pos := range btn.positions {
+			if pos < numPositions {
+				need := targetJoltages[pos] - current[pos]
+				if need > maxNeeded {
+					maxNeeded = need
+				}
+			}
+		}
+
+		minResult := int(1e9)
+
+		for presses := 0; presses <= maxNeeded; presses++ {
+			newCurrent := make([]int, numPositions)
+			copy(newCurrent, current)
+			valid := true
+
+			for _, pos := range btn.positions {
+				if pos < numPositions {
+					newCurrent[pos] += presses
+					if newCurrent[pos] > targetJoltages[pos] {
+						valid = false
+						break
+					}
+				}
+			}
+
+			if valid {
+				result := dp(btnIdx+1, newCurrent)
+				if result < 1e9 {
+					total := presses + result
+					if total < minResult {
+						minResult = total
+					}
+				}
+			}
+		}
+
+		memo[state] = minResult
+		return minResult
+	}
+
+	initial := make([]int, numPositions)
+	result := dp(0, initial)
+
+	if result >= 1e9 {
+		return 0, false
+	}
+	return result, true
+}

utils/polyfence/polyfence.go

@@ -26,15 +26,50 @@ func (p Polygon) Copy() Polygon {
 }
 
 func (pf *Polyfence) Inside(P image.Point) bool {
+	// First check if point is on an edge
+	if pf.OnEdge(P) {
+		return true
+	}
 	return !(checkOutside(pf.p, P) == 0)
 }
 
+func (pf *Polyfence) OnEdge(P image.Point) bool {
+	n := len(pf.p) - 1
+	for i := 0; i < n; i++ {
+		p1, p2 := pf.p[i], pf.p[i+1]
+
+		// Check if P is on the line segment from p1 to p2
+		// Point is on segment if it's collinear and between p1 and p2
+
+		// Check if collinear using cross product
+		cross := (p2.X-p1.X)*(P.Y-p1.Y) - (P.X-p1.X)*(p2.Y-p1.Y)
+		if cross != 0 {
+			continue
+		}
+
+		// Check if P is between p1 and p2
+		minX, maxX := p1.X, p2.X
+		if minX > maxX {
+			minX, maxX = maxX, minX
+		}
+		minY, maxY := p1.Y, p2.Y
+		if minY > maxY {
+			minY, maxY = maxY, minY
+		}
+
+		if P.X >= minX && P.X <= maxX && P.Y >= minY && P.Y <= maxY {
+			return true
+		}
+	}
+	return false
+}
+
 func checkOutside(p Polygon, P image.Point) (res int) {
 	if len(p) < 3 {
 		return 0
 	}
-	edges := len(p) - 2
-	for i := 0; i <= edges; i++ {
+	n := len(p) - 1 // Since we append first point to close, check all edges
+	for i := 0; i < n; i++ {
 		if p[i].Y <= P.Y {
 			if p[i+1].Y > P.Y {
 				if isLeft(p[i], p[i+1], P) > 0 {

utils/utils.go

@@ -69,7 +69,10 @@ func Abs[T Number](i T) T {
 }
 
 func IntPow(n, m int) int {
-	if m == 0 || n == 0 {
+	if m == 0 {
+		return 1
+	}
+	if n == 0 {
 		return 0
 	}
 	if m == 1 {