Revert "buggy not monte carlo"

This reverts commit 413708b0c1f494291702b15ab723a1a41ce6b042.

main.go

@@ -154,125 +154,92 @@ func save() {
 	fmt.Printf("%d\n", bestTotalScore)
 }
 
-func (c *Car) AssignRideRecur(r *Ride, cumulativeScore int, depth int, fromDepth int) (int, bool) {
-	r.used = true
-	oldC := *c
-	c.Update(r)
-	Sched.Add(c)
-	// recursion 101
-	rdepth, fix := Choose(cumulativeScore+c.score-oldC.score, depth+1, fromDepth)
-	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
-	return rdepth, fix
-}
-
-func (c *Car) CanPick(r *Ride) bool {
-	return !r.used && r.Length() <= 8000 && r.f >= c.EarliestFinish(r)
-}
-
-func (c *Car) pickBestRide() *Ride {
-	var bestRide *Ride
-	var bestRideTotal int
-	var bestRideLen int
-
-	for _, r := range Rides {
-		if !c.CanPick(r) {
-			continue
-		}
-
-		lenOfRide := r.length()
-		total := max(c.distanceTo(r.a, r.b), r.s-c.Arrival) + lenOfRide
-		if bestRide == nil || lenOfRide*bestRideTotal > total*bestRideLen {
-			bestRide = r
-			bestRideLen = lenOfRide
-			bestRideTotal = total
-		}
+// 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
+		save()
+	}
+	c := Sched.Pop()
+	if c == nil {
+		// Stop recursion, empty car list,
+		// could not match cars to rides
+		return
 	}
 
-	return bestRide
-}
-
-func (c *Car) pickRandomRide() *Ride {
-	count := 0
+	var bestRides []struct {
+		r         *Ride
+		lenOfRide int
+		total     int
+	}
+	// fmt.Printf("car %d\n", c.ID)
 	for _, r := range Rides {
-		if !c.CanPick(r) {
+		if r.used {
 			continue
 		}
-		count++
-	}
-	i := rand.Intn(count)
-	for _, r := range Rides {
-		if !c.CanPick(r) {
+		if r.Length() > 8000 {
 			continue
 		}
-		if i == 0 {
-			return r
+		if r.f < c.EarliestFinish(r) {
+			continue
 		}
-		i = i - 1
-	}
-	return nil
-}
-
-// 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)
-// Return value (a,b) :
-// - rdepth >= 0 return back to that depth
-// - rdepth < 0 completely unwind stack and finish
-// - fix == false try to make a change at depth `rdepth'
-// - fix == true change back, use "optimal" ride again
-func Choose(cumulativeScore int, depth int, fromDepth int) (int, bool) {
-	c := Sched.Pop()
-	if c == nil {
-		// At this point we have a complete configuration
-		fmt.Printf("score obtained: %d depth: %d\n", cumulativeScore, depth)
-		// INVESTIGATE HERE : why do we have different scores ???
-		// when we're only asking to fix 22 down in the stack
-		return 8270, true
-		if cumulativeScore >= bestTotalScore {
-			bestTotalScore = cumulativeScore
-			// Go back to random depth and make a new change
-			return rand.Intn(depth), false
-		} else {
-			// Go back to fix change that lowered our score
-			return fromDepth, true
+		// fmt.Printf("%d %d -> %d %d\n", r.a, r.b, r.x, r.y)
+		lenOfRide := r.length()
+		total := max(c.distanceTo(r.a, r.b), r.s-c.Arrival) + lenOfRide
+		// fmt.Printf("%d/%d\n", lenOfRide, total)
+		if len(bestRides) == 0 || lenOfRide*bestRides[len(bestRides)-1].total > total*bestRides[len(bestRides)-1].lenOfRide {
+			bestRides = append(bestRides, struct {
+				r         *Ride
+				lenOfRide int
+				total     int
+			}{r, lenOfRide, total})
+			// shitty sort-of-correct-but-quite-incorrect way
+			// of picking next best n rides
+			n := 1
+			if rand.Intn(max(1, int(N/20))) == 0 {
+				n = 2
+			}
+			if len(bestRides) > n {
+				bestRides = bestRides[len(bestRides)-n:]
+			}
 		}
 	}
-
-	var rdepth int
-	var fix bool
-	r := c.pickBestRide()
-	// if depth >= 252 && depth <= 258 {
-	// 	fmt.Printf("yo picking id %d score %d c=%+v\n", r.ID, cumulativeScore, c)
+	// if bestRide != nil {
+	// 	fmt.Printf("Picking %d %d -> %d %d\n", bestRide.a, bestRide.b, bestRide.x, bestRide.y)
 	// }
-	if r != nil {
-		rdepth, fix = c.AssignRideRecur(r, cumulativeScore, depth, fromDepth)
-		// if depth == reverse depth, make a change
-		// and go back up the stack
-		for depth == rdepth {
-			var r *Ride
-			if fix {
-				r = c.pickBestRide()
-				fmt.Printf("pickBestRide id %d depth %d\n", r.ID, depth)
-			} else {
-				r = c.pickRandomRide()
-				fmt.Printf("pickRandomRide id %d depth %d\n", r.ID, depth)
+	if len(bestRides) != 0 {
+		if (len(bestRides)) >= 2 {
+			// if big difference in length, try both
+			// otherwise pick best according to score
+			d := abs(bestRides[0].r.length() - bestRides[1].r.length())
+			if d < 1000 {
+				bestRides = bestRides[1:]
 			}
-			// note fromDepth reset to depth
-			rdepth, fix = c.AssignRideRecur(r, cumulativeScore, depth, depth)
+
+		}
+		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
-		rdepth, fix = Choose(cumulativeScore, depth, fromDepth)
+		Choose(cumulativeScore, depth)
 	}
 	// add back the one we popped at beginning of function
 	Sched.Add(c)
-	// go back down the stack
-	return rdepth, fix
 }
 
 func solve() {
@@ -295,7 +262,7 @@ func solve() {
 	}
 
 	// start recursion
-	Choose(0, 0, 0)
+	Choose(0, 0)
 }
 
 func main() {