204 lines
3.4 KiB
Go
204 lines
3.4 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
var comps []Component
|
|
|
|
// Greater than 907
|
|
func main() {
|
|
inp := StdinToStrings()
|
|
for i := range inp {
|
|
comps = append(comps, NewComponent(inp[i]))
|
|
}
|
|
|
|
// Need to build chains of all permutations
|
|
var perms []Bridge
|
|
for i := range comps {
|
|
if comps[i].Has(0) {
|
|
perms = append(perms, Bridge([]Component{comps[i]}))
|
|
}
|
|
}
|
|
|
|
changed := true
|
|
for changed {
|
|
perms, changed = GetNextPerms(perms)
|
|
}
|
|
|
|
var highB Bridge
|
|
highest := 0
|
|
for _, b := range perms {
|
|
if b.Value() > highest {
|
|
highB = b
|
|
highest = b.Value()
|
|
}
|
|
}
|
|
fmt.Println(highB)
|
|
/*
|
|
for _, b := range perms {
|
|
tst := GetAllThatFit(b)
|
|
for i := range tst {
|
|
|
|
}
|
|
|
|
for tst != nil {
|
|
b = b.Add(*tst)
|
|
tst = GetNextBest(b)
|
|
}
|
|
fmt.Println(b)
|
|
}
|
|
*/
|
|
}
|
|
|
|
func GetNextPerms(perms []Bridge) ([]Bridge, bool) {
|
|
var ret []Bridge
|
|
var changed bool
|
|
for i := range perms {
|
|
if !perms[i].IsDone() {
|
|
allComps := GetAllThatFit(perms[i])
|
|
if len(allComps) == 0 {
|
|
ret = append(ret, perms[i].Add(NewComponent("0/0")))
|
|
}
|
|
for j := range allComps {
|
|
ret = append(ret, perms[i].Add(allComps[j]))
|
|
changed = true
|
|
}
|
|
}
|
|
}
|
|
return ret, changed
|
|
}
|
|
|
|
func GetAllThatFit(b Bridge) []Component {
|
|
var ret []Component
|
|
port := b.Needs()
|
|
for i := range comps {
|
|
if comps[i].Has(port) && !b.Has(comps[i]) {
|
|
ret = append(ret, comps[i])
|
|
}
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func GetNextBest(b Bridge) *Component {
|
|
var best *Component
|
|
port := b.Needs()
|
|
for i := range comps {
|
|
if comps[i].Has(port) && !b.Has(comps[i]) {
|
|
if best == nil || comps[i].Value() > best.Value() {
|
|
best = &comps[i]
|
|
}
|
|
}
|
|
}
|
|
return best
|
|
}
|
|
|
|
type Bridge []Component
|
|
|
|
func (b Bridge) IsDone() bool {
|
|
t := []Component(b)
|
|
c := t[len(t)-1]
|
|
return c.Value() == 0
|
|
}
|
|
|
|
func (b Bridge) Value() int {
|
|
var ret int
|
|
for _, v := range []Component(b) {
|
|
ret += v.Value()
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (b Bridge) Has(c Component) bool {
|
|
for _, v := range []Component(b) {
|
|
if v.Name == c.Name {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (b Bridge) Add(c Component) Bridge {
|
|
b = Bridge(append([]Component(b), c))
|
|
return b
|
|
}
|
|
|
|
func (b Bridge) Needs() int {
|
|
t := []Component(b)
|
|
c := t[len(t)-1]
|
|
if len(t) == 1 {
|
|
return c.Other(0)
|
|
}
|
|
c1 := t[len(t)-2]
|
|
|
|
// Find the side of c that doesn't connect with c1
|
|
if c.Has(c1.Side1) {
|
|
return c.Other(c1.Side1)
|
|
}
|
|
return c.Other(c1.Side2)
|
|
}
|
|
|
|
func (b Bridge) String() string {
|
|
ret := "[ "
|
|
for _, v := range []Component(b) {
|
|
ret += v.Name + " "
|
|
}
|
|
return fmt.Sprint(ret+"] ", b.Value())
|
|
}
|
|
|
|
type Component struct {
|
|
Name string
|
|
Side1, Side2 int
|
|
}
|
|
|
|
func NewComponent(in string) Component {
|
|
c := Component{}
|
|
c.Name = in
|
|
pts := strings.Split(in, "/")
|
|
c.Side1 = Atoi(pts[0])
|
|
c.Side2 = Atoi(pts[1])
|
|
return c
|
|
}
|
|
|
|
func (c *Component) Equals(t Component) bool {
|
|
return c.Side1 == t.Side1 && c.Side2 == t.Side2
|
|
}
|
|
|
|
func (c *Component) Value() int {
|
|
return c.Side1 + c.Side2
|
|
}
|
|
|
|
func (c *Component) Has(v int) bool {
|
|
return c.Side1 == v || c.Side2 == v
|
|
}
|
|
|
|
func (c *Component) Other(v int) int {
|
|
if c.Side1 == v {
|
|
return c.Side2
|
|
}
|
|
return c.Side1
|
|
}
|
|
|
|
func Atoi(i string) int {
|
|
var ret int
|
|
var err error
|
|
if ret, err = strconv.Atoi(i); err != nil {
|
|
log.Fatal("Invalid Atoi")
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func StdinToStrings() []string {
|
|
var input []string
|
|
scanner := bufio.NewScanner(os.Stdin)
|
|
for scanner.Scan() {
|
|
input = append(input, scanner.Text())
|
|
}
|
|
return input
|
|
}
|