adventofcode/2016/day24/main.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()
}