main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"fmt"
-	"math/rand"
 	"os"
 	"sort"
 )
@@ -66,7 +65,6 @@ func (rs ByEndtime) Less(i, j int) bool {
 
 type Scheduler interface {
 	Add(*Car)
-	RemoveAtIndex(k int) *Car
 	Pop() *Car
 }
 
@@ -78,8 +76,7 @@ type Car struct {
 	X       int
 	Y       int
 
-	score   int
-	pqindex int // used for removal in prority queue
+	score int
 }
 
 func (c *Car) Update(r *Ride) {
@@ -135,89 +132,74 @@ func max(a, b int) int {
 	}
 }
 
-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
-	}
+func (c *Car) CanPick(r *Ride) bool {
+	return !r.used && r.f >= c.EarliestFinish(r)
+}
 
-	var bestRides []struct {
-		r         *Ride
-		lenOfRide int
-		total     int
-	}
-	// fmt.Printf("car %d\n", c.ID)
+func (c *Car) pickClosestLate() *Ride {
+	var best *Ride
+	var dbest = 999999999
 	for _, r := range Rides {
-		if r.used {
+		if !c.CanPick(r) {
 			continue
 		}
-		if r.Length() > 6000 {
-			continue
+		d := c.distanceTo(r.a, r.b)
+		if d < dbest && d > r.s-c.Arrival {
+			best = r
+			dbest = d
 		}
-		if r.f < c.EarliestFinish(r) {
+	}
+	return best
+}
+
+func Choose(c *Car) *Ride {
+	var bestRide *Ride
+	bestLenOfRide := 0
+	bestTotal := 0
+	// fmt.Printf("car %d\n", c.ID)
+	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/5))) == 0 {
-				n = 3
-			}
-			if len(bestRides) > n {
-				bestRides = bestRides[len(bestRides)-n:]
-			}
+		if bestRide == nil || lenOfRide*bestTotal > total*bestLenOfRide {
+			bestLenOfRide = lenOfRide
+			bestTotal = total
+			bestRide = r
 		}
 	}
 	// if bestRide != nil {
 	// 	fmt.Printf("Picking %d %d -> %d %d\n", bestRide.a, bestRide.b, bestRide.x, bestRide.y)
 	// }
-	if len(bestRides) != 0 {
-		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
+	if bestRide != nil {
+		r := c.pickClosestLate()
+		if r != nil {
+			bestRide = r
 		}
-	} else {
-		// another car may still have other rides
-		Choose(cumulativeScore, depth)
 	}
-	// add back the one we popped at beginning of function
+	return bestRide
+}
+
+func assign() bool {
+	c := Sched.Pop()
+	if c == nil {
+		return false
+	}
+	r := Choose(c)
+	if r == nil {
+		return true
+	}
+	r.used = true
+	c.Update(r)
 	Sched.Add(c)
+
+	return true
 }
 
 func solve() {
-	rand.Seed(1)
-
 	sort.Sort(ByEndtime(Rides))
 
 	Sched = &prioq{}
@@ -234,17 +216,19 @@ func solve() {
 		Sched.Add(c)
 	}
 
-	// start recursion
-	Choose(0, 0)
+	for assign() {
+	}
 
+	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", bestTotalScore)
+	fmt.Printf("%d\n", totalScore)
 }
 
 func main() {
@@ -315,36 +299,31 @@ type prioq struct {
 
 func (pq *prioq) Add(car *Car) {
 	pq.bintree = append(pq.bintree, car)
-	pq.bintree[len(pq.bintree)-1].pqindex = len(pq.bintree) - 1
 
 	// Rebalance tree to respect invariant
 	var i = len(pq.bintree) - 1
 	var p = (i - 1) / 2
 	for p >= 0 && pq.bintree[p].Arrival > pq.bintree[i].Arrival {
 		pq.bintree[p], pq.bintree[i] = pq.bintree[i], pq.bintree[p]
-		pq.bintree[p].pqindex = p
-		pq.bintree[i].pqindex = i
 		i = p
 		p = (i - 1) / 2
 	}
 }
 
-func (pq *prioq) RemoveAtIndex(k int) *Car {
+func (pq *prioq) Pop() *Car {
 	if len(pq.bintree) == 0 {
 		return nil
 	}
 
-	if k == len(pq.bintree)-1 {
-		elem := pq.bintree[k]
-		pq.bintree = pq.bintree[:k]
+	if len(pq.bintree) == 1 {
+		elem := pq.bintree[0]
+		pq.bintree = pq.bintree[:0]
 		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]
-	pq.bintree[k].pqindex = k
+	elem := pq.bintree[0]
+	// Put last element at root
+	pq.bintree[0] = pq.bintree[len(pq.bintree)-1]
 	// Remove last element
 	pq.bintree = pq.bintree[:len(pq.bintree)-1]
 
@@ -355,8 +334,7 @@ func (pq *prioq) RemoveAtIndex(k int) *Car {
 
 	// Rebalance tree to respect invariant
 	len := len(pq.bintree)
-	i := k
-	left, right := 0, 0
+	i, left, right := 0, 0, 0
 	for {
 		left = 2*i + 1
 		right = 2*i + 2
@@ -366,8 +344,6 @@ func (pq *prioq) RemoveAtIndex(k int) *Car {
 					break // Inferior to both children
 				} else {
 					pq.bintree[i], pq.bintree[left] = pq.bintree[left], pq.bintree[i]
-					pq.bintree[i].pqindex = i
-					pq.bintree[left].pqindex = left
 					i = left
 				}
 			} else {
@@ -375,8 +351,6 @@ func (pq *prioq) RemoveAtIndex(k int) *Car {
 					break // Inferior to both children
 				} else {
 					pq.bintree[i], pq.bintree[right] = pq.bintree[right], pq.bintree[i]
-					pq.bintree[i].pqindex = i
-					pq.bintree[right].pqindex = right
 					i = right
 				}
 			}
@@ -385,8 +359,6 @@ func (pq *prioq) RemoveAtIndex(k int) *Car {
 				break // Inferior to only child
 			}
 			pq.bintree[i], pq.bintree[left] = pq.bintree[left], pq.bintree[i]
-			pq.bintree[i].pqindex = i
-			pq.bintree[left].pqindex = left
 			i = left
 		} else { // No child
 			break
@@ -397,10 +369,6 @@ func (pq *prioq) RemoveAtIndex(k int) *Car {
 	return elem
 }
 
-func (pq *prioq) Pop() *Car {
-	return pq.RemoveAtIndex(0)
-}
-
 func (pq *prioq) empty() bool {
 	return len(pq.bintree) == 0
 }