Day 18 part 1 solution
...sort of. It works, but it takes a lot longer than I'd like on real input. I optimized it with some memoization, but it's still far too slow to be the intended solution. I finished my actual input in over 3 minutes on my macbook m1 (...with the right answer, at least). This solution as-is isn't really going to fly for part 2, though, so I'm probably going to have to re-do it either way.
This commit is contained in:
349
days/18.go
Normal file
349
days/18.go
Normal file
@ -0,0 +1,349 @@
|
||||
package days
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"github.com/beefsack/go-astar"
|
||||
u "parnic.com/aoc2019/utilities"
|
||||
)
|
||||
|
||||
type day18Cell int
|
||||
type day18Vec u.Vec2[int]
|
||||
|
||||
const (
|
||||
day18CellWall day18Cell = iota
|
||||
day18CellOpen
|
||||
)
|
||||
|
||||
var (
|
||||
day18AdjacentOffsets = []day18Vec{
|
||||
{X: -1, Y: 0},
|
||||
{X: 1, Y: 0},
|
||||
{X: 0, Y: -1},
|
||||
{X: 0, Y: 1},
|
||||
}
|
||||
)
|
||||
|
||||
// variables needed for pathfinding
|
||||
// a better solution would be to keep the current path search state in its
|
||||
// own struct and store these on there, but i don't need to worry about
|
||||
// thread safety right now, so this will do fine
|
||||
var (
|
||||
pathGrid [][]day18Cell
|
||||
pathDoors map[day18Vec]int
|
||||
)
|
||||
|
||||
type day18KeySearchResult struct {
|
||||
keyType int
|
||||
path []astar.Pather
|
||||
distance float64
|
||||
found bool
|
||||
}
|
||||
|
||||
type Day18 struct {
|
||||
entrance day18Vec
|
||||
grid [][]day18Cell
|
||||
doors map[day18Vec]int
|
||||
keys map[day18Vec]int
|
||||
knownPaths map[u.Pair[day18Vec, string]]u.Pair[int, bool]
|
||||
}
|
||||
|
||||
func (v day18Vec) PathNeighbors() []astar.Pather {
|
||||
ret := make([]astar.Pather, 0)
|
||||
|
||||
for _, offset := range day18AdjacentOffsets {
|
||||
vOffset := day18Vec{X: v.X + offset.X, Y: v.Y + offset.Y}
|
||||
if vOffset.X < 0 || vOffset.Y < 0 || vOffset.Y >= len(pathGrid) || vOffset.X >= len(pathGrid[0]) {
|
||||
continue
|
||||
}
|
||||
|
||||
if _, exists := pathDoors[vOffset]; exists {
|
||||
continue
|
||||
}
|
||||
|
||||
if pathGrid[vOffset.Y][vOffset.X] == day18CellOpen {
|
||||
ret = append(ret, vOffset)
|
||||
}
|
||||
}
|
||||
|
||||
return ret
|
||||
}
|
||||
|
||||
func (v day18Vec) PathNeighborCost(to astar.Pather) float64 {
|
||||
return 1
|
||||
}
|
||||
|
||||
func (v day18Vec) PathEstimatedCost(to astar.Pather) float64 {
|
||||
// this is insanely more complicated than i feel like it should be.
|
||||
// i guess generics aren't quite as flexible as i'd hoped. Go doesn't
|
||||
// seem to know that a day18Vec is a vec2i which is a vec2[int].
|
||||
return float64(u.ManhattanDistance(u.Vec2[int]{X: v.X, Y: v.Y}, u.Vec2[int]{X: to.(day18Vec).X, Y: to.(day18Vec).Y}))
|
||||
}
|
||||
|
||||
func (d *Day18) Parse() {
|
||||
d.doors = make(map[day18Vec]int)
|
||||
d.keys = make(map[day18Vec]int)
|
||||
d.knownPaths = make(map[u.Pair[day18Vec, string]]u.Pair[int, bool])
|
||||
|
||||
lines := u.GetStringLines("18s6")
|
||||
d.grid = make([][]day18Cell, len(lines))
|
||||
for i, line := range lines {
|
||||
d.grid[i] = make([]day18Cell, len(line))
|
||||
for j, char := range line {
|
||||
if char == '#' {
|
||||
d.grid[i][j] = day18CellWall
|
||||
} else if char == '.' {
|
||||
d.grid[i][j] = day18CellOpen
|
||||
} else if char == '@' {
|
||||
d.grid[i][j] = day18CellOpen
|
||||
d.entrance = day18Vec{X: j, Y: i}
|
||||
} else if char >= 'A' && char <= 'Z' {
|
||||
d.grid[i][j] = day18CellOpen
|
||||
d.doors[day18Vec{X: j, Y: i}] = int(char - 'A')
|
||||
} else if char >= 'a' && char <= 'z' {
|
||||
d.grid[i][j] = day18CellOpen
|
||||
d.keys[day18Vec{X: j, Y: i}] = int(char - 'a')
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pathGrid = d.grid
|
||||
}
|
||||
|
||||
func (d Day18) Num() int {
|
||||
return 18
|
||||
}
|
||||
|
||||
func (d Day18) Draw(grid [][]day18Cell, keys, doors map[day18Vec]int, entrances ...day18Vec) {
|
||||
for y := range grid {
|
||||
for x := range grid[y] {
|
||||
switch grid[y][x] {
|
||||
case day18CellWall:
|
||||
fmt.Print("█")
|
||||
case day18CellOpen:
|
||||
posVec := day18Vec{X: x, Y: y}
|
||||
if _, exists := doors[posVec]; exists {
|
||||
fmt.Printf("%c", rune(doors[posVec]+'A'))
|
||||
} else if _, exists := keys[posVec]; exists {
|
||||
fmt.Printf("%c", rune(keys[posVec]+'a'))
|
||||
} else if u.ArrayContains(entrances, posVec) {
|
||||
fmt.Print("@")
|
||||
} else {
|
||||
fmt.Print(".")
|
||||
}
|
||||
}
|
||||
}
|
||||
fmt.Println()
|
||||
}
|
||||
}
|
||||
|
||||
func (d *Day18) pickUpKey(atPosition day18Vec, keys, doors map[day18Vec]int) {
|
||||
key, exists := keys[atPosition]
|
||||
if !exists {
|
||||
panic("tried to pick up a key that either doesn't exist or was already picked up")
|
||||
}
|
||||
|
||||
var matchingDoorPos day18Vec
|
||||
foundDoor := false
|
||||
for doorPos, doorType := range doors {
|
||||
if doorType == key {
|
||||
matchingDoorPos = doorPos
|
||||
foundDoor = true
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
delete(keys, atPosition)
|
||||
// the last key has no door, so we should only fail this once. should.
|
||||
if foundDoor {
|
||||
delete(doors, matchingDoorPos)
|
||||
}
|
||||
}
|
||||
|
||||
func astarPathContains(arr []astar.Pather, find astar.Pather) bool {
|
||||
for _, v := range arr {
|
||||
if v == find {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
func (d Day18) findReachableKeys(pos day18Vec, keys, doors map[day18Vec]int) map[day18Vec]day18KeySearchResult {
|
||||
pathDoors = doors
|
||||
|
||||
ret := make(map[day18Vec]day18KeySearchResult)
|
||||
for keyPos, keyType := range keys {
|
||||
path, distance, found := astar.Path(pos, keyPos)
|
||||
if found {
|
||||
ret[keyPos] = day18KeySearchResult{
|
||||
keyType: keyType,
|
||||
path: path,
|
||||
distance: distance,
|
||||
found: found,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if len(ret) < 2 {
|
||||
return ret
|
||||
}
|
||||
|
||||
filtered := make(map[day18Vec]day18KeySearchResult)
|
||||
// filter out keys that require you to walk through another key to get to them
|
||||
for keyPos, key := range ret {
|
||||
eligible := true
|
||||
for checkKeyPos := range ret {
|
||||
if keyPos == checkKeyPos {
|
||||
continue
|
||||
}
|
||||
|
||||
if astarPathContains(key.path, checkKeyPos) {
|
||||
eligible = false
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if eligible {
|
||||
filtered[keyPos] = key
|
||||
}
|
||||
}
|
||||
|
||||
return filtered
|
||||
}
|
||||
|
||||
func (d Day18) tryPickupKey(inKeys, inDoors map[day18Vec]int, keyPos day18Vec, keyResult day18KeySearchResult) (int, bool) {
|
||||
keys := u.CopyMap(inKeys)
|
||||
doors := u.CopyMap(inDoors)
|
||||
|
||||
d.pickUpKey(keyPos, keys, doors)
|
||||
totalDist := int(keyResult.distance)
|
||||
|
||||
if len(keys) == 0 {
|
||||
return totalDist, true
|
||||
}
|
||||
|
||||
sb := strings.Builder{}
|
||||
keyVals := u.MapValues(keys)
|
||||
sort.Slice(keyVals, func(i, j int) bool { return keyVals[i] < keyVals[j] })
|
||||
for i, v := range keyVals {
|
||||
if i > 0 {
|
||||
sb.WriteRune(',')
|
||||
}
|
||||
sb.WriteString(fmt.Sprintf("%d", v))
|
||||
}
|
||||
vecToKey := u.Pair[day18Vec, string]{First: keyPos, Second: sb.String()}
|
||||
if v, exists := d.knownPaths[vecToKey]; exists {
|
||||
return totalDist + v.First, v.Second
|
||||
}
|
||||
|
||||
shortestDist := math.MaxInt
|
||||
reachableKeys := d.findReachableKeys(keyPos, keys, doors)
|
||||
if len(reachableKeys) == 0 {
|
||||
// panic("no reachable keys")
|
||||
return math.MaxInt, false
|
||||
}
|
||||
// fmt.Println("in.", len(reachableKeys), "reachable keys")
|
||||
done := false
|
||||
for reachableKeyPos, keyResult := range reachableKeys {
|
||||
bestDist, finished := d.tryPickupKey(keys, doors, reachableKeyPos, keyResult)
|
||||
if bestDist < shortestDist {
|
||||
shortestDist = bestDist
|
||||
done = finished
|
||||
}
|
||||
}
|
||||
// fmt.Println("out")
|
||||
d.knownPaths[vecToKey] = u.Pair[int, bool]{First: shortestDist, Second: done}
|
||||
|
||||
totalDist += shortestDist
|
||||
|
||||
return totalDist, done
|
||||
}
|
||||
|
||||
func (d Day18) part2PatchMap(grid [][]day18Cell, entrance day18Vec) []day18Vec {
|
||||
grid[entrance.Y-1][entrance.X] = day18CellWall
|
||||
grid[entrance.Y][entrance.X-1] = day18CellWall
|
||||
grid[entrance.Y][entrance.X] = day18CellWall
|
||||
grid[entrance.Y][entrance.X+1] = day18CellWall
|
||||
grid[entrance.Y+1][entrance.X] = day18CellWall
|
||||
|
||||
return []day18Vec{
|
||||
{X: entrance.X - 1, Y: entrance.Y - 1},
|
||||
{X: entrance.X + 1, Y: entrance.Y - 1},
|
||||
{X: entrance.X - 1, Y: entrance.Y + 1},
|
||||
{X: entrance.X + 1, Y: entrance.Y + 1},
|
||||
}
|
||||
}
|
||||
|
||||
func (d *Day18) Part1() string {
|
||||
pos := d.entrance
|
||||
keys := u.CopyMap(d.keys)
|
||||
doors := u.CopyMap(d.doors)
|
||||
|
||||
fmt.Println("initial state:")
|
||||
d.Draw(d.grid, keys, doors, pos)
|
||||
|
||||
bestDist := math.MaxInt
|
||||
|
||||
reachableKeys := d.findReachableKeys(pos, keys, doors)
|
||||
if len(reachableKeys) == 0 {
|
||||
panic("failed to find a key to pick up")
|
||||
}
|
||||
for keyPos, keyResult := range reachableKeys {
|
||||
shortestPath, _ := d.tryPickupKey(keys, doors, keyPos, keyResult)
|
||||
if shortestPath < bestDist {
|
||||
bestDist = shortestPath
|
||||
}
|
||||
}
|
||||
|
||||
// fmt.Printf("Moving to pick up key %c (cost: %d, total cost so far: %d)\n", rune(closestKey+'a'), closestDist, totalDist)
|
||||
// d.Draw(pos, keys, doors)
|
||||
|
||||
return fmt.Sprintf("Total distance traveled: %s%d%s", u.TextBold, bestDist, u.TextReset)
|
||||
}
|
||||
|
||||
func (d *Day18) Part2() string {
|
||||
keys := u.CopyMap(d.keys)
|
||||
doors := u.CopyMap(d.doors)
|
||||
d.knownPaths = make(map[u.Pair[day18Vec, string]]u.Pair[int, bool])
|
||||
|
||||
fmt.Println("initial state:")
|
||||
grid := make([][]day18Cell, len(d.grid))
|
||||
for i := range d.grid {
|
||||
grid[i] = make([]day18Cell, len(d.grid[i]))
|
||||
copy(grid[i], d.grid[i])
|
||||
}
|
||||
pathGrid = grid
|
||||
|
||||
entrances := d.part2PatchMap(grid, d.entrance)
|
||||
d.Draw(grid, keys, doors, entrances...)
|
||||
|
||||
bestDist := math.MaxInt
|
||||
|
||||
// reachableKeys := d.findReachableKeys(entrances[0], keys, doors)
|
||||
// if len(reachableKeys) == 0 {
|
||||
// panic("failed to find a key to pick up")
|
||||
// }
|
||||
done := true
|
||||
for !done {
|
||||
for _, entrance := range entrances {
|
||||
reachableKeys := d.findReachableKeys(entrance, keys, doors)
|
||||
for keyPos, keyResult := range reachableKeys {
|
||||
shortestPath, finished := d.tryPickupKey(keys, doors, keyPos, keyResult)
|
||||
if shortestPath < bestDist {
|
||||
bestDist = shortestPath
|
||||
done = finished
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// fmt.Printf("Moving to pick up key %c (cost: %d, total cost so far: %d)\n", rune(closestKey+'a'), closestDist, totalDist)
|
||||
// d.Draw(pos, keys, doors)
|
||||
|
||||
return fmt.Sprintf("Total distance traveled: %s%d%s", u.TextBold, bestDist, u.TextReset)
|
||||
}
|
||||
Reference in New Issue
Block a user