Remove unused solver algorithms (SA, hybrid, original hill climb)
This commit is contained in:
Ian Gulliver
676
solver/solver.go
676
solver/solver.go
@@ -1,7 +1,6 @@
|
||||
package solver
|
||||
|
||||
import (
|
||||
"math"
|
||||
"math/rand"
|
||||
"slices"
|
||||
"strconv"
|
||||
@@ -28,34 +27,6 @@ var DefaultParams = Params{
|
||||
PerturbMax: 8,
|
||||
}
|
||||
|
||||
type SAParams struct {
|
||||
Restarts int
|
||||
Steps int
|
||||
TempHigh float64
|
||||
TempLow float64
|
||||
}
|
||||
|
||||
var DefaultSAParams = SAParams{
|
||||
Restarts: 20,
|
||||
Steps: 10000,
|
||||
TempHigh: 5.0,
|
||||
TempLow: 0.01,
|
||||
}
|
||||
|
||||
type HybridParams struct {
|
||||
SARestarts int
|
||||
SASteps int
|
||||
TempHigh float64
|
||||
TempLow float64
|
||||
}
|
||||
|
||||
var DefaultHybridParams = HybridParams{
|
||||
SARestarts: 50,
|
||||
SASteps: 5000,
|
||||
TempHigh: 10.0,
|
||||
TempLow: 0.1,
|
||||
}
|
||||
|
||||
type Solution struct {
|
||||
Assignment []int
|
||||
Score int
|
||||
@@ -251,14 +222,6 @@ func (s *solverState) score(assignment []int) int {
|
||||
return sc
|
||||
}
|
||||
|
||||
func (s *solverState) roomCounts(assignment []int) []int {
|
||||
counts := make([]int, s.numRooms)
|
||||
for _, room := range assignment {
|
||||
counts[room]++
|
||||
}
|
||||
return counts
|
||||
}
|
||||
|
||||
func (s *solverState) feasibleForGroup(assignment []int, groupRoot int, room int) bool {
|
||||
for _, m := range s.groups[groupRoot] {
|
||||
for _, partner := range s.mustApartFor[m] {
|
||||
@@ -634,200 +597,6 @@ func (t *solutionTracker) add(a []int, s int) {
|
||||
}
|
||||
}
|
||||
|
||||
func Solve(n, roomSize, pnMultiple, npCost int, constraints []Constraint, params Params, rng *rand.Rand) []Solution {
|
||||
if n == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
st := newSolverState(n, roomSize, pnMultiple, npCost, constraints)
|
||||
if st.hasHardConflict() {
|
||||
return nil
|
||||
}
|
||||
|
||||
assignment := make([]int, n)
|
||||
if !st.initialPlacement(assignment) {
|
||||
for i := range n {
|
||||
assignment[i] = i % st.numRooms
|
||||
}
|
||||
}
|
||||
|
||||
initialAssignment := slices.Clone(assignment)
|
||||
tracker := newTracker(assignment, st.score(assignment))
|
||||
|
||||
roomCount := func(a []int, room int) int {
|
||||
c := 0
|
||||
for _, r := range a {
|
||||
if r == room {
|
||||
c++
|
||||
}
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
feasible := func(a []int) bool {
|
||||
for p := range st.mustApart {
|
||||
if a[p[0]] == a[p[1]] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
rc := map[int]int{}
|
||||
for _, room := range a {
|
||||
rc[room]++
|
||||
}
|
||||
for _, cnt := range rc {
|
||||
if cnt > roomSize {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
hillClimb := func(assignment []int) int {
|
||||
currentScore := st.score(assignment)
|
||||
for {
|
||||
bestDelta := 0
|
||||
bestMove := -1
|
||||
bestTarget := -1
|
||||
bestSwapJ := -1
|
||||
|
||||
for gi, gRoot := range st.uniqueGroups {
|
||||
grp := st.groups[gRoot]
|
||||
gRoom := assignment[grp[0]]
|
||||
|
||||
for room := range st.numRooms {
|
||||
if room == gRoom {
|
||||
continue
|
||||
}
|
||||
if roomCount(assignment, room)+len(grp) > roomSize {
|
||||
continue
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = room
|
||||
}
|
||||
if feasible(assignment) {
|
||||
delta := st.score(assignment) - currentScore
|
||||
if delta > bestDelta {
|
||||
bestDelta = delta
|
||||
bestMove = gi
|
||||
bestTarget = room
|
||||
bestSwapJ = -1
|
||||
}
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = gRoom
|
||||
}
|
||||
}
|
||||
|
||||
for gj := gi + 1; gj < len(st.uniqueGroups); gj++ {
|
||||
grp2 := st.groups[st.uniqueGroups[gj]]
|
||||
g2Room := assignment[grp2[0]]
|
||||
if gRoom == g2Room {
|
||||
continue
|
||||
}
|
||||
newGRoom := roomCount(assignment, gRoom) - len(grp) + len(grp2)
|
||||
newG2Room := roomCount(assignment, g2Room) - len(grp2) + len(grp)
|
||||
if newGRoom > roomSize || newG2Room > roomSize {
|
||||
continue
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = gRoom
|
||||
}
|
||||
if feasible(assignment) {
|
||||
delta := st.score(assignment) - currentScore
|
||||
if delta > bestDelta {
|
||||
bestDelta = delta
|
||||
bestMove = gi
|
||||
bestTarget = -1
|
||||
bestSwapJ = gj
|
||||
}
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = gRoom
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if bestDelta <= 0 {
|
||||
break
|
||||
}
|
||||
|
||||
grp := st.groups[st.uniqueGroups[bestMove]]
|
||||
gRoom := assignment[grp[0]]
|
||||
if bestSwapJ < 0 {
|
||||
for _, m := range grp {
|
||||
assignment[m] = bestTarget
|
||||
}
|
||||
} else {
|
||||
grp2 := st.groups[st.uniqueGroups[bestSwapJ]]
|
||||
g2Room := assignment[grp2[0]]
|
||||
for _, m := range grp {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = gRoom
|
||||
}
|
||||
}
|
||||
currentScore += bestDelta
|
||||
}
|
||||
return currentScore
|
||||
}
|
||||
|
||||
perturb := func(src []int, count int) {
|
||||
copy(assignment, src)
|
||||
indices := rng.Perm(len(st.uniqueGroups))
|
||||
count = min(count, len(indices))
|
||||
for _, gi := range indices[:count] {
|
||||
grp := st.groups[st.uniqueGroups[gi]]
|
||||
oldRoom := assignment[grp[0]]
|
||||
rooms := rng.Perm(st.numRooms)
|
||||
for _, room := range rooms {
|
||||
if room == oldRoom {
|
||||
continue
|
||||
}
|
||||
if roomCount(assignment, room)+len(grp) > roomSize {
|
||||
continue
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = room
|
||||
}
|
||||
if feasible(assignment) {
|
||||
break
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
copy(assignment, initialAssignment)
|
||||
tracker.add(assignment, hillClimb(assignment))
|
||||
|
||||
for range params.NumRandom {
|
||||
if st.randomPlacement(assignment, rng) {
|
||||
tracker.add(assignment, hillClimb(assignment))
|
||||
}
|
||||
}
|
||||
|
||||
for range params.NumPerturb {
|
||||
src := tracker.bestSolutions[rng.Intn(len(tracker.bestSolutions))]
|
||||
perturb(src, params.PerturbMin+rng.Intn(params.PerturbMax-params.PerturbMin))
|
||||
tracker.add(assignment, hillClimb(assignment))
|
||||
}
|
||||
|
||||
results := make([]Solution, len(tracker.bestSolutions))
|
||||
for i, sol := range tracker.bestSolutions {
|
||||
results[i] = Solution{Assignment: sol, Score: tracker.bestScore}
|
||||
}
|
||||
return results
|
||||
}
|
||||
|
||||
func SolveFast(n, roomSize, pnMultiple, npCost int, constraints []Constraint, params Params, rng *rand.Rand) []Solution {
|
||||
if n == 0 {
|
||||
return nil
|
||||
@@ -926,448 +695,3 @@ func SolveFast(n, roomSize, pnMultiple, npCost int, constraints []Constraint, pa
|
||||
return results
|
||||
}
|
||||
|
||||
func SolveSA(n, roomSize, pnMultiple, npCost int, constraints []Constraint, params SAParams, rng *rand.Rand) []Solution {
|
||||
if n == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
st := newSolverState(n, roomSize, pnMultiple, npCost, constraints)
|
||||
if st.hasHardConflict() {
|
||||
return nil
|
||||
}
|
||||
|
||||
assignment := make([]int, n)
|
||||
if !st.initialPlacement(assignment) {
|
||||
for i := range n {
|
||||
assignment[i] = i % st.numRooms
|
||||
}
|
||||
}
|
||||
|
||||
tracker := newTracker(assignment, st.score(assignment))
|
||||
counts := st.roomCounts(assignment)
|
||||
|
||||
tryMove := func(assignment []int, counts []int, rng *rand.Rand) (gi int, oldRoom int, newRoom int, swapGi int, ok bool) {
|
||||
nGroups := len(st.uniqueGroups)
|
||||
gi = rng.Intn(nGroups)
|
||||
grp := st.groups[st.uniqueGroups[gi]]
|
||||
oldRoom = assignment[grp[0]]
|
||||
|
||||
if rng.Intn(3) == 0 && nGroups > 1 {
|
||||
swapGi = rng.Intn(nGroups - 1)
|
||||
if swapGi >= gi {
|
||||
swapGi++
|
||||
}
|
||||
grp2 := st.groups[st.uniqueGroups[swapGi]]
|
||||
g2Room := assignment[grp2[0]]
|
||||
if oldRoom == g2Room {
|
||||
return 0, 0, 0, 0, false
|
||||
}
|
||||
newOldCount := counts[oldRoom] - len(grp) + len(grp2)
|
||||
newG2Count := counts[g2Room] - len(grp2) + len(grp)
|
||||
if newOldCount > roomSize || newG2Count > roomSize {
|
||||
return 0, 0, 0, 0, false
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
if !st.feasibleForGroup(assignment, st.uniqueGroups[gi], g2Room) ||
|
||||
!st.feasibleForGroup(assignment, st.uniqueGroups[swapGi], oldRoom) {
|
||||
for _, m := range grp {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
return 0, 0, 0, 0, false
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
return gi, oldRoom, g2Room, swapGi, true
|
||||
}
|
||||
|
||||
newRoom = rng.Intn(st.numRooms - 1)
|
||||
if newRoom >= oldRoom {
|
||||
newRoom++
|
||||
}
|
||||
if counts[newRoom]+len(grp) > roomSize {
|
||||
return 0, 0, 0, 0, false
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = newRoom
|
||||
}
|
||||
if !st.feasibleForGroup(assignment, st.uniqueGroups[gi], newRoom) {
|
||||
for _, m := range grp {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
return 0, 0, 0, 0, false
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
return gi, oldRoom, newRoom, -1, true
|
||||
}
|
||||
|
||||
applyMove := func(assignment []int, counts []int, gi, oldRoom, newRoom, swapGi int) {
|
||||
grp := st.groups[st.uniqueGroups[gi]]
|
||||
if swapGi >= 0 {
|
||||
grp2 := st.groups[st.uniqueGroups[swapGi]]
|
||||
g2Room := assignment[grp2[0]]
|
||||
counts[oldRoom] -= len(grp)
|
||||
counts[g2Room] -= len(grp2)
|
||||
for _, m := range grp {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
counts[g2Room] += len(grp)
|
||||
counts[oldRoom] += len(grp2)
|
||||
} else {
|
||||
counts[oldRoom] -= len(grp)
|
||||
for _, m := range grp {
|
||||
assignment[m] = newRoom
|
||||
}
|
||||
counts[newRoom] += len(grp)
|
||||
}
|
||||
}
|
||||
|
||||
for restart := range params.Restarts {
|
||||
if restart > 0 {
|
||||
if !st.randomPlacement(assignment, rng) {
|
||||
continue
|
||||
}
|
||||
counts = st.roomCounts(assignment)
|
||||
}
|
||||
|
||||
currentScore := st.score(assignment)
|
||||
|
||||
for step := range params.Steps {
|
||||
t := params.TempHigh * math.Pow(params.TempLow/params.TempHigh, float64(step)/float64(params.Steps-1))
|
||||
|
||||
gi, oldRoom, newRoom, swapGi, ok := tryMove(assignment, counts, rng)
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
|
||||
applyMove(assignment, counts, gi, oldRoom, newRoom, swapGi)
|
||||
newScore := st.score(assignment)
|
||||
delta := newScore - currentScore
|
||||
|
||||
if delta >= 0 || rng.Float64() < math.Exp(float64(delta)/t) {
|
||||
currentScore = newScore
|
||||
tracker.add(assignment, currentScore)
|
||||
} else {
|
||||
if swapGi >= 0 {
|
||||
grp := st.groups[st.uniqueGroups[gi]]
|
||||
grp2 := st.groups[st.uniqueGroups[swapGi]]
|
||||
g2Room := assignment[grp2[0]]
|
||||
counts[g2Room] -= len(grp2)
|
||||
counts[oldRoom] -= len(grp)
|
||||
for _, m := range grp {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
counts[oldRoom] += len(grp)
|
||||
counts[g2Room] += len(grp2)
|
||||
} else {
|
||||
grp := st.groups[st.uniqueGroups[gi]]
|
||||
counts[newRoom] -= len(grp)
|
||||
for _, m := range grp {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
counts[oldRoom] += len(grp)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
results := make([]Solution, len(tracker.bestSolutions))
|
||||
for i, sol := range tracker.bestSolutions {
|
||||
results[i] = Solution{Assignment: sol, Score: tracker.bestScore}
|
||||
}
|
||||
return results
|
||||
}
|
||||
|
||||
func SolveHybrid(n, roomSize, pnMultiple, npCost int, constraints []Constraint, params HybridParams, rng *rand.Rand) []Solution {
|
||||
if n == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
st := newSolverState(n, roomSize, pnMultiple, npCost, constraints)
|
||||
if st.hasHardConflict() {
|
||||
return nil
|
||||
}
|
||||
|
||||
numRooms := st.numRooms
|
||||
|
||||
roomCount := func(a []int, room int) int {
|
||||
c := 0
|
||||
for _, r := range a {
|
||||
if r == room {
|
||||
c++
|
||||
}
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
feasible := func(a []int) bool {
|
||||
for p := range st.mustApart {
|
||||
if a[p[0]] == a[p[1]] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
rc := map[int]int{}
|
||||
for _, room := range a {
|
||||
rc[room]++
|
||||
}
|
||||
for _, cnt := range rc {
|
||||
if cnt > roomSize {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
hillClimb := func(assignment []int) int {
|
||||
currentScore := st.score(assignment)
|
||||
for {
|
||||
bestDelta := 0
|
||||
bestMove := -1
|
||||
bestTarget := -1
|
||||
bestSwapJ := -1
|
||||
|
||||
for gi, gRoot := range st.uniqueGroups {
|
||||
grp := st.groups[gRoot]
|
||||
gRoom := assignment[grp[0]]
|
||||
|
||||
for room := range numRooms {
|
||||
if room == gRoom {
|
||||
continue
|
||||
}
|
||||
if roomCount(assignment, room)+len(grp) > roomSize {
|
||||
continue
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = room
|
||||
}
|
||||
if feasible(assignment) {
|
||||
delta := st.score(assignment) - currentScore
|
||||
if delta > bestDelta {
|
||||
bestDelta = delta
|
||||
bestMove = gi
|
||||
bestTarget = room
|
||||
bestSwapJ = -1
|
||||
}
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = gRoom
|
||||
}
|
||||
}
|
||||
|
||||
for gj := gi + 1; gj < len(st.uniqueGroups); gj++ {
|
||||
grp2 := st.groups[st.uniqueGroups[gj]]
|
||||
g2Room := assignment[grp2[0]]
|
||||
if gRoom == g2Room {
|
||||
continue
|
||||
}
|
||||
newGRoom := roomCount(assignment, gRoom) - len(grp) + len(grp2)
|
||||
newG2Room := roomCount(assignment, g2Room) - len(grp2) + len(grp)
|
||||
if newGRoom > roomSize || newG2Room > roomSize {
|
||||
continue
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = gRoom
|
||||
}
|
||||
if feasible(assignment) {
|
||||
delta := st.score(assignment) - currentScore
|
||||
if delta > bestDelta {
|
||||
bestDelta = delta
|
||||
bestMove = gi
|
||||
bestTarget = -1
|
||||
bestSwapJ = gj
|
||||
}
|
||||
}
|
||||
for _, m := range grp {
|
||||
assignment[m] = gRoom
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if bestDelta <= 0 {
|
||||
break
|
||||
}
|
||||
|
||||
grp := st.groups[st.uniqueGroups[bestMove]]
|
||||
gRoom := assignment[grp[0]]
|
||||
if bestSwapJ < 0 {
|
||||
for _, m := range grp {
|
||||
assignment[m] = bestTarget
|
||||
}
|
||||
} else {
|
||||
grp2 := st.groups[st.uniqueGroups[bestSwapJ]]
|
||||
g2Room := assignment[grp2[0]]
|
||||
for _, m := range grp {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = gRoom
|
||||
}
|
||||
}
|
||||
currentScore += bestDelta
|
||||
}
|
||||
return currentScore
|
||||
}
|
||||
|
||||
assignment := make([]int, n)
|
||||
if !st.initialPlacement(assignment) {
|
||||
for i := range n {
|
||||
assignment[i] = i % numRooms
|
||||
}
|
||||
}
|
||||
|
||||
tracker := newTracker(assignment, st.score(assignment))
|
||||
tracker.add(assignment, hillClimb(assignment))
|
||||
|
||||
counts := make([]int, numRooms)
|
||||
|
||||
for restart := range params.SARestarts {
|
||||
if restart == 0 {
|
||||
copy(assignment, tracker.bestSolutions[0])
|
||||
} else {
|
||||
if !st.randomPlacement(assignment, rng) {
|
||||
continue
|
||||
}
|
||||
}
|
||||
for i := range counts {
|
||||
counts[i] = 0
|
||||
}
|
||||
for _, room := range assignment {
|
||||
counts[room]++
|
||||
}
|
||||
|
||||
currentScore := st.score(assignment)
|
||||
|
||||
for step := range params.SASteps {
|
||||
t := params.TempHigh * math.Pow(params.TempLow/params.TempHigh, float64(step)/float64(params.SASteps-1))
|
||||
|
||||
nGroups := len(st.uniqueGroups)
|
||||
gi := rng.Intn(nGroups)
|
||||
grp := st.groups[st.uniqueGroups[gi]]
|
||||
oldRoom := assignment[grp[0]]
|
||||
|
||||
var newRoom int
|
||||
swapGi := -1
|
||||
moved := false
|
||||
|
||||
if rng.Intn(3) == 0 && nGroups > 1 {
|
||||
swapGi = rng.Intn(nGroups - 1)
|
||||
if swapGi >= gi {
|
||||
swapGi++
|
||||
}
|
||||
grp2 := st.groups[st.uniqueGroups[swapGi]]
|
||||
g2Room := assignment[grp2[0]]
|
||||
if oldRoom != g2Room {
|
||||
newOld := counts[oldRoom] - len(grp) + len(grp2)
|
||||
newG2 := counts[g2Room] - len(grp2) + len(grp)
|
||||
if newOld <= roomSize && newG2 <= roomSize {
|
||||
for _, m := range grp {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
if st.feasibleForGroup(assignment, st.uniqueGroups[gi], g2Room) &&
|
||||
st.feasibleForGroup(assignment, st.uniqueGroups[swapGi], oldRoom) {
|
||||
newRoom = g2Room
|
||||
moved = true
|
||||
counts[oldRoom] = newOld
|
||||
counts[g2Room] = newG2
|
||||
} else {
|
||||
for _, m := range grp {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if !moved {
|
||||
swapGi = -1
|
||||
newRoom = rng.Intn(numRooms - 1)
|
||||
if newRoom >= oldRoom {
|
||||
newRoom++
|
||||
}
|
||||
if counts[newRoom]+len(grp) <= roomSize {
|
||||
for _, m := range grp {
|
||||
assignment[m] = newRoom
|
||||
}
|
||||
if st.feasibleForGroup(assignment, st.uniqueGroups[gi], newRoom) {
|
||||
moved = true
|
||||
counts[oldRoom] -= len(grp)
|
||||
counts[newRoom] += len(grp)
|
||||
} else {
|
||||
for _, m := range grp {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if !moved {
|
||||
continue
|
||||
}
|
||||
|
||||
newScore := st.score(assignment)
|
||||
delta := newScore - currentScore
|
||||
|
||||
if delta >= 0 || rng.Float64() < math.Exp(float64(delta)/t) {
|
||||
currentScore = newScore
|
||||
} else {
|
||||
if swapGi >= 0 {
|
||||
grp2 := st.groups[st.uniqueGroups[swapGi]]
|
||||
g2Room := assignment[grp2[0]]
|
||||
for _, m := range grp {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
for _, m := range grp2 {
|
||||
assignment[m] = g2Room
|
||||
}
|
||||
counts[oldRoom] = counts[oldRoom] - len(grp2) + len(grp)
|
||||
counts[g2Room] = counts[g2Room] - len(grp) + len(grp2)
|
||||
} else {
|
||||
for _, m := range grp {
|
||||
assignment[m] = oldRoom
|
||||
}
|
||||
counts[newRoom] -= len(grp)
|
||||
counts[oldRoom] += len(grp)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
tracker.add(assignment, hillClimb(assignment))
|
||||
}
|
||||
|
||||
results := make([]Solution, len(tracker.bestSolutions))
|
||||
for i, sol := range tracker.bestSolutions {
|
||||
results[i] = Solution{Assignment: sol, Score: tracker.bestScore}
|
||||
}
|
||||
return results
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user