maximum-path-quality-of-a-graph

maximum-path-quality-of-a-graph/sol.go

@@ -0,0 +1,70 @@
+package main
+
+type Next struct {
+	Visited map[int]bool
+	Time    int
+	Node    int
+}
+
+type Edge struct {
+	To   int
+	Time int
+}
+
+// Horrible, unoptimised solution that I could come up with
+// Should learn how to do depth-first-search properly
+func maximalPathQuality(values []int, edges [][]int, maxTime int) int {
+	next := []*Next{
+		{
+			Visited: map[int]bool{0: true},
+			Time:    0,
+			Node:    0,
+		},
+	}
+	es := map[int][]*Edge{}
+	for _, edge := range edges {
+		_, ok := es[edge[0]]
+		if !ok {
+			es[edge[0]] = []*Edge{}
+		}
+		_, ok = es[edge[1]]
+		if !ok {
+			es[edge[1]] = []*Edge{}
+		}
+		es[edge[0]] = append(es[edge[0]], &Edge{To: edge[1], Time: edge[2]})
+		es[edge[1]] = append(es[edge[1]], &Edge{To: edge[0], Time: edge[2]})
+	}
+	maxQuality := values[0]
+	for len(next) != 0 {
+		_next := []*Next{}
+		for _, n := range next {
+			if n.Node == 0 && n.Time != 0 {
+				q := 0
+				for node := range n.Visited {
+					q += values[node]
+				}
+				if q > maxQuality {
+					maxQuality = q
+				}
+			}
+			nedges, ok := es[n.Node]
+			if ok {
+				for _, nedge := range nedges {
+					if !(n.Time+nedge.Time > maxTime) {
+						v := map[int]bool{nedge.To: true}
+						for key := range n.Visited {
+							v[key] = true
+						}
+						_next = append(_next, &Next{
+							Visited: v,
+							Time:    n.Time + nedge.Time,
+							Node:    nedge.To,
+						})
+					}
+				}
+			}
+		}
+		next = _next
+	}
+	return maxQuality
+}