public override Decision Next(Solver solver) { foreach (ConstraintProblem.ConstraintModelNode node in constraintProblem.Tray) { IntVar var = node.Route; if (!var.Bound()) { int min = (int)var.Min(); if (min == 0) { min++; // We erase the 0 since the GCC constraints will fix that } int max = (int)var.Max(); int rndVal = rnd.Next(min, max + 1); while (!var.Contains(rndVal)) { rndVal = rnd.Next(min, max + 1); } return(solver.MakeAssignVariableValue(var, rndVal)); } } return(null); }
public override Decision Next(Solver solver) { int large = 100000; int number_of_variables = vars_.Length; long last_slot = last_slot_var_.Max(); // Lets build a bipartite graph with equal number of nodes left and right. // Variables will be on the left, slots on the right. // We will add dummy variables when needed. // Arcs will have a cost x is slot x is possible for a variable, a large // number otherwise. For dummy variables, the cost will be 0 always. LinearSumAssignment matching = new LinearSumAssignment(); for (int speaker = 0; speaker < number_of_variables; ++speaker) { IntVar var = vars_[speaker]; for (int value = first_slot_; value <= last_slot; ++value) { if (var.Contains(value)) { matching.AddArcWithCost(speaker, value - first_slot_, value); } else { matching.AddArcWithCost(speaker, value - first_slot_, large); } } } // The Matching algorithms expect the same number of left and right nodes. // So we fill the rest with dense zero-cost arcs. for (int dummy = number_of_variables; dummy <= last_slot - first_slot_; ++dummy) { for (int value = first_slot_; value <= last_slot; ++value) { matching.AddArcWithCost(dummy, value - first_slot_, 0); } } if (matching.Solve() == LinearSumAssignment.OPTIMAL && matching.OptimalCost() < large) // No violated arcs. { for (int speaker = 0; speaker < number_of_variables; ++speaker) { vars_[speaker].SetValue(matching.RightMate(speaker) + first_slot_); } } else { solver.Fail(); } return(null); }