Recursion to try a few different routes - score: 47.9M

Probably not a good strategy for three reasons : a) code is quite a
bit more complex b) gain is all relative (only 15k on third input)
and c) it's long to execute, already ~3.5 minutes

Only score is calculated, not the actual resulting out files (it would
require saving alongside bestTotalScore)

main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"math/rand"
 	"os"
 	"sort"
 )
@@ -134,7 +135,23 @@ func max(a, b int) int {
 	}
 }
 
-func Choose(c *Car) *Ride {
+var bestTotalScore int
+
+// invariant : when entering and leaving function,
+// Sched has the "same" heap. Same means successive
+// popped values will be the same (but the internal
+// ordering of nodes may be different)
+func Choose(cumulativeScore int, depth int) {
+	if cumulativeScore > bestTotalScore {
+		bestTotalScore = cumulativeScore
+	}
+	c := Sched.Pop()
+	if c == nil {
+		// Stop recursion, empty car list,
+		// could not match cars to rides
+		return
+	}
+
 	var bestRides []struct {
 		r         *Ride
 		lenOfRide int
@@ -145,9 +162,9 @@ func Choose(c *Car) *Ride {
 		if r.used {
 			continue
 		}
-		// if r.Length() > 6000 {
-		// 	continue
-		// }
+		if r.Length() > 6000 {
+			continue
+		}
 		if r.f < c.EarliestFinish(r) {
 			continue
 		}
@@ -163,7 +180,10 @@ func Choose(c *Car) *Ride {
 			}{r, lenOfRide, total})
 			// shitty sort-of-correct-but-quite-incorrect way
 			// of picking next best n rides
-			n := 3
+			n := 1
+			if rand.Intn(max(1, int(N/5))) == 0 {
+				n = 3
+			}
 			if len(bestRides) > n {
 				bestRides = bestRides[len(bestRides)-n:]
 			}
@@ -173,31 +193,31 @@ func Choose(c *Car) *Ride {
 	// 	fmt.Printf("Picking %d %d -> %d %d\n", bestRide.a, bestRide.b, bestRide.x, bestRide.y)
 	// }
 	if len(bestRides) != 0 {
-		// pick the not quite best ride...hey some
-		// of the inputs already  give a better score !
-		return bestRides[0].r
-		//return bestRides[len(bestRides)-1].r
-	}
-	return nil
-}
-
-func assign() bool {
-	c := Sched.Pop()
-	if c == nil {
-		return false
-	}
-	r := Choose(c)
-	if r == nil {
-		return true
+		for _, br := range bestRides {
+			r := br.r
+			r.used = true
+			oldC := *c
+			c.Update(r)
+			Sched.Add(c)
+			// recursion 101
+			Choose(cumulativeScore+c.score-oldC.score, depth+1)
+			Sched.RemoveAtIndex(c.pqindex)
+			// pqindex is meaningless now but it's ok
+			// it will be fixed when c is added again
+			*c = oldC
+			r.used = false
+		}
+	} else {
+		// another car may still have other rides
+		Choose(cumulativeScore, depth)
 	}
-	r.used = true
-	c.Update(r)
+	// add back the one we popped at beginning of function
 	Sched.Add(c)
-
-	return true
 }
 
 func solve() {
+	rand.Seed(1)
+
 	sort.Sort(ByEndtime(Rides))
 
 	Sched = &prioq{}
@@ -214,19 +234,17 @@ func solve() {
 		Sched.Add(c)
 	}
 
-	for assign() {
-	}
+	// start recursion
+	Choose(0, 0)
 
-	totalScore := 0
 	for _, c := range Cars {
 		fmt.Fprintf(output, "%d", len(c.Rides))
 		for _, ri := range c.Rides {
 			fmt.Fprintf(output, " %d", ri)
 		}
 		fmt.Fprintf(output, "\n")
-		totalScore += c.score
 	}
-	fmt.Printf("%d\n", totalScore)
+	fmt.Printf("%d\n", bestTotalScore)
 }
 
 func main() {
@@ -322,6 +340,7 @@ func (pq *prioq) RemoveAtIndex(k int) *Car {
 		return elem
 	}
 
+	pq.bintree[k].pqindex = -1
 	elem := pq.bintree[k]
 	// Put last element at hole
 	pq.bintree[k] = pq.bintree[len(pq.bintree)-1]