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);
}
