buggy not monte carlo

main.go

@@ -154,92 +154,125 @@ func save() {
 	fmt.Printf("%d\n", bestTotalScore)
 }
 
-// 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
-	}
+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
 
-	var bestRides []struct {
-		r         *Ride
-		lenOfRide int
-		total     int
-	}
-	// fmt.Printf("car %d\n", c.ID)
 	for _, r := range Rides {
-		if r.used {
+		if !c.CanPick(r) {
 			continue
 		}
-		if r.Length() > 8000 {
+
+		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
+		}
+	}
+
+	return bestRide
+}
+
+func (c *Car) pickRandomRide() *Ride {
+	count := 0
+	for _, r := range Rides {
+		if !c.CanPick(r) {
 			continue
 		}
-		if r.f < c.EarliestFinish(r) {
+		count++
+	}
+	i := rand.Intn(count)
+	for _, r := range Rides {
+		if !c.CanPick(r) {
 			continue
 		}
-		// 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:]
-			}
+		if i == 0 {
+			return r
 		}
+		i = i - 1
 	}
-	// if bestRide != nil {
-	// 	fmt.Printf("Picking %d %d -> %d %d\n", bestRide.a, bestRide.b, bestRide.x, bestRide.y)
-	// }
-	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:]
-			}
+	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
 		}
-		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
+	}
+
+	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 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)
+			}
+			// note fromDepth reset to depth
+			rdepth, fix = c.AssignRideRecur(r, cumulativeScore, depth, depth)
 		}
 	} else {
 		// another car may still have other rides
-		Choose(cumulativeScore, depth)
+		rdepth, fix = Choose(cumulativeScore, depth, fromDepth)
 	}
 	// add back the one we popped at beginning of function
 	Sched.Add(c)
+	// go back down the stack
+	return rdepth, fix
 }
 
 func solve() {
@@ -262,7 +295,7 @@ func solve() {
 	}
 
 	// start recursion
-	Choose(0, 0)
+	Choose(0, 0, 0)
 }
 
 func main() {