adventofcode/2016/day24/main.go

501 lines
11 KiB
Go

package main
import (
"fmt"
"math"
"os"
"sort"
"time"
"github.com/fatih/color"
h "git.bullercodeworks.com/brian/adventofcode/helpers"
)
var tWidth, tHeight int
func main() {
fileNm := h.GetArgNumber(1)
if len(os.Args) < 2 {
fmt.Println("Usage: ./day24 <mazefile>")
os.Exit(1)
}
var f *Floor
var poiString string
f = CreateFloorFromFile(fileNm)
for i := 0; i < len(f.pois); i++ {
poiString += f.pois[i].Name()
if f.debug {
for j := i + 1; j < len(f.pois); j++ {
idx := f.pois[i].Name() + ";" + f.pois[j].Name()
fmt.Println(idx, f.shortestPaths[idx])
}
}
}
poiPerms := h.StringPermutations(poiString)
shortest := -1
var shortestPerm string
for _, perm := range poiPerms {
if perm[0] != '0' {
continue
}
if h.ArgIsSet("-2") {
// For part 2 we return to 0
perm = perm + "0"
}
var permTtl int
for i := range perm {
if i > 0 {
beg, end := string(perm[i-1]), string(perm[i])
if beg[0] > end[0] {
beg, end = end, beg
}
permTtl += f.shortestPaths[beg+";"+end]
}
}
if permTtl < shortest || shortest == -1 {
shortestPerm = perm
shortest = permTtl
}
}
fmt.Println(shortestPerm, ": ", shortest)
}
type Floor struct {
cells []string
start *Coord
end *Coord
pois []Coord
shortestPaths map[string]int
testedPath Path
solvePath Path
cellCount int
debug bool
}
func CreateFloorFromFile(fileNm string) *Floor {
f := new(Floor)
f.debug = h.ArgIsSet("-d")
f.cells = h.FileToStringSlice(fileNm)
for y := range f.cells {
for x := range f.cells[y] {
if f.cells[y][x] != '#' {
f.cellCount++
}
if f.cells[y][x] != '#' && f.cells[y][x] != '.' {
// A point of interest
wrkCoord := NewCoord(x, y, f.cells[y][x])
f.pois = append(f.pois, *wrkCoord)
if f.cells[y][x] == '0' {
f.start = wrkCoord
}
}
}
}
// Sort the pois
sort.Sort(CoordByLabel(f.pois))
// Find the shortest paths between all points of interest
f.shortestPaths = make(map[string]int)
if h.ArgIsSet("-2") {
/* Output from running part 1
1;2 232
1;3 30
1;4 188
1;5 230
1;6 80
1;7 54
2;3 218
2;4 56
2;5 74
2;6 212
2;7 278
3;4 174
3;5 216
3;6 66
3;7 80
4;5 54
4;6 168
4;7 234
5;6 210
5;7 276
6;7 126
*/
f.shortestPaths["0;1"] = 30
f.shortestPaths["0;2"] = 258
f.shortestPaths["0;3"] = 56
f.shortestPaths["0;4"] = 214
f.shortestPaths["0;5"] = 256
f.shortestPaths["0;6"] = 106
f.shortestPaths["0;7"] = 44
f.shortestPaths["1;2"] = 232
f.shortestPaths["1;3"] = 30
f.shortestPaths["1;4"] = 188
f.shortestPaths["1;5"] = 230
f.shortestPaths["1;6"] = 80
f.shortestPaths["1;7"] = 54
f.shortestPaths["2;3"] = 218
f.shortestPaths["2;4"] = 56
f.shortestPaths["2;5"] = 74
f.shortestPaths["2;6"] = 212
f.shortestPaths["2;7"] = 278
f.shortestPaths["3;4"] = 174
f.shortestPaths["3;5"] = 216
f.shortestPaths["3;6"] = 66
f.shortestPaths["3;7"] = 80
f.shortestPaths["4;5"] = 54
f.shortestPaths["4;6"] = 168
//f.shortestPaths["4;7"] = 266
//f.shortestPaths["5;6"] = 262
//f.shortestPaths["5;7"] = 304
f.shortestPaths["6;7"] = 126
}
for i := range f.pois {
for j := range f.pois {
if i != j {
one, two := f.pois[i], f.pois[j]
if one.label > two.label {
one, two = two, one
}
idx := string(one.label) + ";" + string(two.label)
if _, ok := f.shortestPaths[idx]; !ok {
p := f.GetShortestPath(&one, &two)
if f.debug {
fmt.Println(p.Name())
f.PrintPath(p)
fmt.Println("Path length:", len(p.coords), "\n")
for i := range p.coords {
fmt.Print(p.coords[i].Name(), ",")
}
fmt.Println()
}
f.shortestPaths[idx] = len(p.coords) - 1
}
}
}
}
return f
}
func (f *Floor) GetPoi(lbl byte) *Coord {
for i := range f.pois {
if f.pois[i].label == lbl {
return &f.pois[i]
}
}
return nil
}
var shortestFound int
func (f *Floor) GetShortestPath(st, end *Coord) Path {
f.solvePath = *new(Path)
f.testedPath = *new(Path)
hldStart := f.start
f.start = end
f.end = st
shortestFound = -1
path, sol := f.Solve(f.start.x, f.start.y, 0)
f.start = hldStart
if sol {
return path
}
return *new(Path)
}
func (f *Floor) Print() {
for y := range f.cells {
for x := range f.cells[y] {
fmt.Print(string(f.cells[y][x]))
}
fmt.Println()
}
}
func (f *Floor) PrintPath(p Path) {
pathCol := color.New(color.BgGreen)
for y := range f.cells {
for x := range f.cells[y] {
if p.ContainsCoord(x, y) {
if f.cells[y][x] == '.' {
pathCol.Print("O")
} else {
pathCol.Print(string(f.cells[y][x]))
}
} else {
fmt.Print(string(f.cells[y][x]))
}
}
fmt.Println()
}
}
func (f *Floor) IsWall(x, y int) bool {
return f.cells[y][x] == '#'
}
func (f *Floor) GetCoord(x, y int) *Coord {
return NewCoord(x, y, f.cells[y][x])
}
func (f *Floor) Solve(x, y, dist int) (Path, bool) {
var tPathContains bool
shortest := new(Path)
wrkCoord := *f.GetCoord(x, y)
wrkCoord.dist = dist
if f.end.Is(x, y) {
shortest.Append(wrkCoord)
if shortestFound == -1 || dist < shortestFound {
shortestFound = dist
}
return *shortest, true
}
if f.IsWall(x, y) || (shortestFound != -1 && dist > shortestFound) {
return *shortest, false
}
// Test if we already have this coord via a shorter path
if t := f.testedPath.GetCoordAt(x, y); t != nil {
if t.dist <= dist {
return *shortest, false
}
tPathContains = true
t.dist = dist
}
// Test if there is a shorter path to this coordinate
if !f.IsWall(x-1, y) {
if t := f.testedPath.GetCoordAt(x-1, y); t != nil {
if t.dist+1 < wrkCoord.dist {
return *shortest, false
}
}
}
if !f.IsWall(x+1, y) {
if t := f.testedPath.GetCoordAt(x+1, y); t != nil {
if t.dist+1 < wrkCoord.dist {
return *shortest, false
}
}
}
if !f.IsWall(x, y-1) {
if t := f.testedPath.GetCoordAt(x, y-1); t != nil {
if t.dist+1 < wrkCoord.dist {
return *shortest, false
}
}
}
if !f.IsWall(x, y+1) {
if t := f.testedPath.GetCoordAt(x, y+1); t != nil {
if t.dist+1 < wrkCoord.dist {
return *shortest, false
}
}
}
// We haven't found a shorter path to this coordinate, so carry on
if !tPathContains {
f.testedPath.Append(wrkCoord)
if f.debug {
fmt.Println(h.ClearScreen, f.start.Name(), "=>", f.end.Name(), "\n", len(f.testedPath.coords), "/", f.cellCount, "\n", "Shortest:", shortestFound)
f.PrintPath(f.testedPath)
time.Sleep(time.Millisecond * 50)
}
}
var solvePaths []Path
var didN, didE, didS, didW bool
var preferNS bool
if math.Abs(float64(f.end.y-y)) > math.Abs(float64(f.end.x-x)) {
// Favor N/S movements
preferNS = true
}
for tdir := 0; tdir < 2; tdir++ {
if preferNS {
switch {
case f.end.y < y && !didN:
f.TestAndUpdate(x, y-1, dist+1)
if p, sol := f.Solve(x, y-1, wrkCoord.dist+1); sol {
p.Append(wrkCoord)
solvePaths = append(solvePaths, p)
}
didN = true
case f.end.y > y && !didS:
f.TestAndUpdate(x, y+1, dist+1)
if p, sol := f.Solve(x, y+1, wrkCoord.dist+1); sol {
p.Append(wrkCoord)
solvePaths = append(solvePaths, p)
}
didS = true
case f.end.x > x && !didE:
f.TestAndUpdate(x+1, y, dist+1)
if p, sol := f.Solve(x+1, y, wrkCoord.dist+1); sol {
p.Append(wrkCoord)
solvePaths = append(solvePaths, p)
}
didE = true
case f.end.x < x && !didW:
f.TestAndUpdate(x-1, y, dist+1)
if p, sol := f.Solve(x-1, y, wrkCoord.dist+1); sol {
p.Append(wrkCoord)
solvePaths = append(solvePaths, p)
}
didW = true
}
} else {
switch {
case f.end.x > x && !didE:
f.TestAndUpdate(x+1, y, dist+1)
if p, sol := f.Solve(x+1, y, wrkCoord.dist+1); sol {
p.Append(wrkCoord)
solvePaths = append(solvePaths, p)
}
didE = true
case f.end.x < x && !didW:
f.TestAndUpdate(x-1, y, dist+1)
if p, sol := f.Solve(x-1, y, wrkCoord.dist+1); sol {
p.Append(wrkCoord)
solvePaths = append(solvePaths, p)
}
didW = true
case f.end.y < y && !didN:
f.TestAndUpdate(x, y-1, dist+1)
if p, sol := f.Solve(x, y-1, wrkCoord.dist+1); sol {
p.Append(wrkCoord)
solvePaths = append(solvePaths, p)
}
didN = true
case f.end.y > y && !didS:
f.TestAndUpdate(x, y+1, dist+1)
if p, sol := f.Solve(x, y+1, wrkCoord.dist+1); sol {
p.Append(wrkCoord)
solvePaths = append(solvePaths, p)
}
didS = true
}
}
}
if !didN {
f.TestAndUpdate(x, y-1, dist+1)
if p, sol := f.Solve(x, y-1, wrkCoord.dist+1); sol {
p.Append(wrkCoord)
solvePaths = append(solvePaths, p)
}
}
if !didE {
f.TestAndUpdate(x+1, y, dist+1)
if p, sol := f.Solve(x+1, y, wrkCoord.dist+1); sol {
p.Append(wrkCoord)
solvePaths = append(solvePaths, p)
}
}
if !didS {
f.TestAndUpdate(x, y+1, dist+1)
if p, sol := f.Solve(x, y+1, wrkCoord.dist+1); sol {
p.Append(wrkCoord)
solvePaths = append(solvePaths, p)
}
}
if !didW {
f.TestAndUpdate(x-1, y, dist+1)
if p, sol := f.Solve(x-1, y, wrkCoord.dist+1); sol {
p.Append(wrkCoord)
solvePaths = append(solvePaths, p)
}
}
var sol bool
if sol = len(solvePaths) > 0; sol {
shortest = &solvePaths[0]
for i := range solvePaths {
if solvePaths[i].Length()+1 < shortest.Length() {
shortest = &solvePaths[i]
}
}
}
return *shortest, sol
}
func (f *Floor) TestAndUpdate(x, y, dist int) {
if t := f.testedPath.GetCoordAt(x, y); t != nil {
if t.dist > dist+1 {
f.testedPath.SetCoordDist(x, y, dist+1)
}
}
}
type Coord struct {
x, y, dist int
label byte
}
func NewCoord(x, y int, label byte) *Coord {
return &Coord{x, y, -1, label}
}
func (c *Coord) Name() string {
if c.label != '#' && c.label != '.' && c.label != 0 {
return string(c.label)
}
return fmt.Sprint("(", c.x, ",", c.y, ")")
}
func (c *Coord) Is(x, y int) bool {
return c.x == x && c.y == y
}
type CoordByLabel []Coord
func (a CoordByLabel) Len() int { return len(a) }
func (a CoordByLabel) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a CoordByLabel) Less(i, j int) bool { return a[i].label < a[j].label }
type Path struct {
coords []Coord
}
func (p *Path) Append(c Coord) {
p.coords = append(p.coords, c)
}
func (p *Path) ContainsCoord(x, y int) bool {
for i := range p.coords {
if p.coords[i].Is(x, y) {
return true
}
}
return false
}
func (p *Path) GetCoordAt(x, y int) *Coord {
for i := range p.coords {
if p.coords[i].Is(x, y) {
return &p.coords[i]
}
}
return nil
}
func (p *Path) SetCoordDist(x, y, dist int) bool {
for i := range p.coords {
if p.coords[i].Is(x, y) {
p.coords[i].dist = dist
return true
}
}
return false
}
func (p *Path) Length() int {
return len(p.coords)
}
func (p *Path) Name() string {
return p.coords[0].Name() + " -> " + p.coords[len(p.coords)-1].Name()
}