/*
* Print Game Board:
*/
private static void PrintSolution(IntVar[,] board, String[] rows, String[] cols)
{
if (rows.GetLength(0) != board.GetLength(0) || cols.GetLength(0) != board.GetLength(1))
{
throw new ArgumentException("Dimensions do not match !");
}
Console.Write("".PadRight(rows[0].Length + 2, ' '));
for (int j = 0; j < board.GetLength(1); j++)
{
Console.Write("[{0}] ", cols[j]);
}
Console.WriteLine();
for (int i = 0; i < board.GetLength(0); i++)
{
Console.Write("{0}: ", rows[i]);
for (int j = 0; j < board.GetLength(1); j++)
{
Console.Write("[{0}] ", board[i, j].Value());
}
Console.WriteLine();
}
}
/*
* Print Game Board:
*/
private static void PrintSolution(IntVar[,] board, int[] frameSums)
{
for (int i = 0; i < 9; i++)
{
Console.Write(" ");
Console.Write(frameSums[i].ToString("D2"));
}
Console.WriteLine();
for (int i = 0; i < board.GetLength(0); i++)
{
Console.Write(frameSums[1 * 9 + i].ToString("D2"));
for (int j = 0; j < board.GetLength(1); j++)
{
Console.Write("[{0}] ", board[i, j].Value());
}
Console.Write(frameSums[2 * 9 + i].ToString("D2"));
Console.WriteLine();
}
for (int i = 3 * 9; i < 3 * 9 + 9; i++)
{
Console.Write(" ");
Console.Write(frameSums[i].ToString("D2"));
}
}
private static void constrainShiftPattern(IntVar[,] nurses, Solver solver)
{
// Explicit constraints
solver.Add(solver.MakeMax(nurses[2, 0] == nurses[2, 1], nurses[2, 1] == nurses[2, 2]) == 1);
solver.Add(solver.MakeMax(nurses[2, 1] == nurses[2, 2], nurses[2, 2] == nurses[2, 3]) == 1);
solver.Add(solver.MakeMax(nurses[2, 2] == nurses[2, 3], nurses[2, 3] == nurses[2, 4]) == 1);
solver.Add(solver.MakeMax(nurses[2, 3] == nurses[2, 4], nurses[2, 4] == nurses[2, 5]) == 1);
solver.Add(solver.MakeMax(nurses[2, 4] == nurses[2, 5], nurses[2, 5] == nurses[2, 6]) == 1);
solver.Add(solver.MakeMax(nurses[2, 5] == nurses[2, 6], nurses[2, 6] == nurses[2, 0]) == 1);
solver.Add(solver.MakeMax(nurses[2, 6] == nurses[2, 0], nurses[2, 0] == nurses[2, 1]) == 1);
solver.Add(solver.MakeMax(nurses[3, 0] == nurses[3, 1], nurses[3, 1] == nurses[3, 2]) == 1);
solver.Add(solver.MakeMax(nurses[3, 1] == nurses[3, 2], nurses[3, 2] == nurses[3, 3]) == 1);
solver.Add(solver.MakeMax(nurses[3, 2] == nurses[3, 3], nurses[3, 3] == nurses[3, 4]) == 1);
solver.Add(solver.MakeMax(nurses[3, 3] == nurses[3, 4], nurses[3, 4] == nurses[3, 5]) == 1);
solver.Add(solver.MakeMax(nurses[3, 4] == nurses[3, 5], nurses[3, 5] == nurses[3, 6]) == 1);
solver.Add(solver.MakeMax(nurses[3, 5] == nurses[3, 6], nurses[3, 6] == nurses[3, 0]) == 1);
solver.Add(solver.MakeMax(nurses[3, 6] == nurses[3, 0], nurses[3, 0] == nurses[3, 1]) == 1);
// Loop achieves the same constraints
//foreach (var shift in new[] { 2, 3 })
//{
// for (int d = 0; d < numberDays; d++)
// {
// int nextDay = (d + 1) % 7;
// int dayAfterNext = (d + 2) % 7;
// solver.Add(solver.MakeMax(nurses[shift, d] == nurses[shift, nextDay], nurses[shift, nextDay] == nurses[shift, dayAfterNext]) == 1);
// }
//}
}
// ReSharper disable once UnusedParameter.Local
private IEnumerable <Constraint> DefineConstraints(Solver solver, IntVar[,] compositionVars)
{
// ReSharper disable once IdentifierTypo
IntExpr MakeDenomComposite(Denomination d)
=> compositionVars[(int)d, 0] * compositionVars[(int)d, 1];
var onePenceComposite = MakeDenomComposite(OnePence).Register(this);
var twoPenceComposite = MakeDenomComposite(TwoPence).Register(this);
var fivePenceComposite = MakeDenomComposite(FivePence).Register(this);
var tenPenceComposite = MakeDenomComposite(TenPence).Register(this);
var twentyPenceComposite = MakeDenomComposite(TwentyPence).Register(this);
var fiftyPenceComposite = MakeDenomComposite(FiftyPence).Register(this);
var onePoundComposite = MakeDenomComposite(OnePound).Register(this);
var twoPoundsComposite = MakeDenomComposite(TwoPounds).Register(this);
var compositeSum =
onePenceComposite
+ twoPenceComposite
+ fivePenceComposite
+ tenPenceComposite
+ twentyPenceComposite
+ fiftyPenceComposite
+ onePoundComposite
;
compositeSum.Register(this);
var theMoneyConstraint = compositeSum == twoPoundsComposite;
yield return(theMoneyConstraint);
}
public SolutionPrinter(int[] values, int[] colors, int[] allGroups, int[] allItems, IntVar[,] itemInGroup)
{
this._values = values;
this._colors = colors;
this._allGroups = allGroups;
this._allItems = allItems;
this._itemInGroup = itemInGroup;
}
/**
* Ensure that the sum of the segments
* in cc == res
*
*/
public static void calc(Solver solver, int[] cc, IntVar[,] x, int res)
{
// sum the numbers
int len = cc.Length / 2;
solver.Add((from i in Enumerable.Range(0, len) select x[cc[i * 2] - 1, cc[i * 2 + 1] - 1]).ToArray().Sum() ==
res);
}
/**
* Ensure that the sum of the segments
* in cc == res
*
*/
public static void calc(Solver solver,
int[] cc,
IntVar[,] x,
int res)
{
int ccLen = cc.Length;
if (ccLen == 4)
{
// for two operands there's
// a lot of possible variants
IntVar a = x[cc[0] - 1, cc[1] - 1];
IntVar b = x[cc[2] - 1, cc[3] - 1];
IntVar r1 = a + b == res;
IntVar r2 = a * b == res;
IntVar r3 = a * res == b;
IntVar r4 = b * res == a;
IntVar r5 = a - b == res;
IntVar r6 = b - a == res;
solver.Add(r1 + r2 + r3 + r4 + r5 + r6 >= 1);
}
else
{
// For length > 2 then res is either the sum
// the the product of the segment
// sum the numbers
int len = cc.Length / 2;
IntVar[] xx = (from i in Enumerable.Range(0, len)
select x[cc[i * 2] - 1, cc[i * 2 + 1] - 1]).ToArray();
// Sum
IntVar this_sum = xx.Sum() == res;
// Product
// IntVar this_prod = (xx.Prod() == res).Var(); // don't work
IntVar this_prod;
if (xx.Length == 3)
{
this_prod = (x[cc[0] - 1, cc[1] - 1] *
x[cc[2] - 1, cc[3] - 1] *
x[cc[4] - 1, cc[5] - 1]) == res;
}
else
{
this_prod = (
x[cc[0] - 1, cc[1] - 1] *
x[cc[2] - 1, cc[3] - 1] *
x[cc[4] - 1, cc[5] - 1] *
x[cc[6] - 1, cc[7] - 1]) == res;
}
solver.Add(this_sum + this_prod >= 1);
}
}
private static long Solve(long num_buses_check = 0)
{
SolverParameters sPrm = new SolverParameters();
sPrm.compress_trail = 0;
sPrm.trace_level = 0;
sPrm.profile_level = 0;
Solver solver = new Solver("OrTools", sPrm);
//this works
// IntVar[,] x = solver.MakeIntVarMatrix(2,2, new int[] {-2,0,1,2}, "x");
//this doesn't work
IntVar[,] x = solver.MakeIntVarMatrix(2, 2, new int[] { 0, 1, 2 }, "x");
for (int w = 0; w < 2; w++)
{
IntVar[] b = new IntVar[2];
for (int i = 0; i < 2; i++)
{
b[i] = solver.MakeIsEqualCstVar(x[w, i], 0);
}
solver.Add(solver.MakeSumGreaterOrEqual(b, 2));
}
IntVar[] x_flat = x.Flatten();
DecisionBuilder db = solver.MakePhase(x_flat,
Solver.CHOOSE_FIRST_UNBOUND,
Solver.ASSIGN_MIN_VALUE);
solver.NewSearch(db);
while (solver.NextSolution())
{
Console.WriteLine("x: ");
for (int j = 0; j < 2; j++)
{
Console.Write("worker" + (j + 1).ToString() + ":");
for (int i = 0; i < 2; i++)
{
Console.Write(" {0,2} ", x[j, i].Value());
}
Console.Write("\n");
}
Console.WriteLine("End at---->" + DateTime.Now);
}
Console.WriteLine("\nSolutions: {0}", solver.Solutions());
Console.WriteLine("WallTime: {0}ms", solver.WallTime());
Console.WriteLine("Failures: {0}", solver.Failures());
Console.WriteLine("Branches: {0} ", solver.Branches());
solver.EndSearch();
return(1);
}
private static void assignNursesToDifferentShiftsEachDay(IntVar[,] nurses, IntVar[,] shifts, Solver solver)
{
for (int d = 0; d < numberDays; d++)
{
IntVarVector x = Enumerable.Range(0, numberNurses).Select(n => shifts[n, d]).ToArray();
solver.Add(solver.MakeAllDifferent(x));
IntVarVector y = Enumerable.Range(0, numberShifts).Select(s => nurses[s, d]).ToArray();
solver.Add(solver.MakeAllDifferent(y));
}
}
/*
* Print Game Board:
*/
private static void PrintSolution(IntVar[,] board)
{
for (int i = 0; i < board.GetLength(0); i++)
{
for (int j = 0; j < board.GetLength(1); j++)
{
Console.Write("[{0}] ", board[i, j].Value());
}
Console.WriteLine();
}
}
private static void PrintSolution(IntVar[,] magicSquare)
{
for (int i = 0; i < magicSquare.GetLength(0); i++)
{
for (int j = 0; j < magicSquare.GetLength(1); j++)
{
Console.Write("[{00}]", magicSquare[i, j].Value());
}
Console.Write("\n");
}
}
private static void PrintSolution(IntVar[,] binoxxo)
{
for (int i = 0; i < binoxxo.GetLength(0); i++)
{
for (int j = 0; j < binoxxo.GetLength(1); j++)
{
String value = (binoxxo[i, j].Value() == 0 ? "O" : "X");
Console.Write("[{0}]", value);
}
Console.Write("\n");
}
}
private static void setRelationshipBetweenNursesAndShifts(IntVar[,] nurses, IntVar[,] shifts, Solver solver)
{
for (int d = 0; d < numberDays; d++)
{
var nursesForDay = Enumerable.Range(0, numberShifts).Select(x => nurses[x, d]).ToArray();
for (int n = 0; n < numberNurses; n++)
{
var s = shifts[n, d];
solver.Add(s.IndexOf(nursesForDay) == n);
}
}
}
public void doWork()
{
Solver solver = new Solver("MagicSquares");
// Calculate magic number --> Be carefull with very large numbers! --> (int) casting!
int magicNumber = (int)((Math.Pow(this.size, 3) + this.size) / 2);
// n x n Matrix of Decision Variables:
IntVar[,] board = solver.MakeIntVarMatrix(this.size, this.size, 1, size * size);
// Set all squares different
solver.Add(board.Flatten().AllDifferent());
// Handy C# LINQ type for sequences:
IEnumerable <int> RANGE = Enumerable.Range(0, this.size);
// Each sum of row/column equals the magic number:
foreach (int i in RANGE)
{
// Rows:
solver.Add((from j in RANGE select board[i, j]).ToArray().Sum() == magicNumber);
// Columns:
solver.Add((from j in RANGE select board[j, i]).ToArray().Sum() == magicNumber);
}
// Now the two diagonal parts
solver.Add((from j in RANGE select board[j, j]).ToArray().Sum() == magicNumber);
solver.Add((from j in RANGE select board[j, this.size - 1 - j]).ToArray().Sum() == magicNumber);
DecisionBuilder db = solver.MakePhase(
board.Flatten(),
Solver.INT_VAR_SIMPLE,
Solver.INT_VALUE_SIMPLE);
solver.NewSearch(db);
// Calculate first result for this solution
// If more solutions are necessary, you can extend this part with a while(...)-Loop
if (solver.NextSolution())
{
printSquare(board);
}
solver.EndSearch();
if (solver.Solutions() == 0)
{
Console.WriteLine("No possible solution was found for the given magic Square! :-(");
}
}
private static void makeNursesWorkFiveOrSixDays(IntVar[,] shifts, Solver solver)
{
for (int n = 0; n < numberNurses; n++)
{
IntVar[] b = new IntVar[numberDays];
for (int d = 0; d < numberDays; d++)
{
b[d] = (shifts[n, d] > 0).Var();
}
solver.Add(solver.MakeSumGreaterOrEqual(b, 5));
solver.Add(solver.MakeSumLessOrEqual(b, 6));
}
}
/**
* Ensure that the sum of the segments
* in cc == res
*
*/
public static void calc(Solver solver, int[] cc, IntVar[,] x, int res)
{
// ensure that the values are positive
int len = cc.Length / 2;
for (int i = 0; i < len; i++)
{
solver.Add(x[cc[i * 2] - 1, cc[i * 2 + 1] - 1] >= 1);
}
// sum the numbers
solver.Add((from i in Enumerable.Range(0, len) select x[cc[i * 2] - 1, cc[i * 2 + 1] - 1]).ToArray().Sum() ==
res);
}
// Matrix API
public static IntVar[] Flatten(this IntVar[,] vars)
{
int rows = vars.GetLength(0);
int cols = vars.GetLength(1);
IntVar[] flat = new IntVar[cols * rows];
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
flat[i * cols + j] = vars[i, j];
}
}
return(flat);
}
private static void makeMaxTwoNursesForShiftDuringWeek(IntVar[,] worksShift,
Solver solver)
{
for (int s = 1; s < numberShifts; s++)
{
IntVar[] b = new IntVar[numberNurses];
for (int n = 0; n < numberNurses; n++)
{
b[n] = worksShift[n, s];
}
solver.Add(solver.MakeSumLessOrEqual(b, 2));
}
}
private void printSquare(IntVar[,] currentSolution)
{
Console.WriteLine("Possible solution:\n");
for (int row = 0; row < this.size; row++)
{
for (int column = 0; column < this.size; column++)
{
Console.Write(" {0,2}", currentSolution[row, column].Value());
}
Console.Write("\n");
}
Console.WriteLine();
}
public void Solve(GrilleSudoku s)
{
//Création d'un solver Or-tools
Solver solver = new Solver("Sudoku");
//Création de la grille de variables
IntVar[,] grid = solver.MakeIntVarMatrix(9, 9, 1, 9, "grid");
IntVar[] grid_flat = grid.Flatten();
//Masque de résolution
foreach (int i in cellIndices)
{
foreach (int j in cellIndices)
{
if (s.GetCellule(i, j) > 0)
{
solver.Add(grid[i, j] == s.GetCellule(i, j));
}
}
}
//Un chiffre ne figure qu'une seule fois par ligne/colonne/cellule
foreach (int i in cellIndices)
{
// Lignes
solver.Add((from j in cellIndices
select grid[i, j]).ToArray().AllDifferent());
// Colonnes
}
//Cellules
//Début de la résolution
DecisionBuilder db = solver.MakePhase(grid_flat,
Solver.INT_VAR_SIMPLE,
Solver.INT_VALUE_SIMPLE);
solver.NewSearch(db);
//Mise à jour du sudoku
}
public override IEnumerable <IntVar> GetVariables(Solver source)
{
Cells = new IntVar[Size, Size];
for (var row = MinimumValue; row < MaximumValue; row++)
{
for (var col = MinimumValue; col < MaximumValue; col++)
{
Cells[row, col] = source.MakeIntVar(MinimumValue + 1, MaximumValue, $"[{row},{col}]");
}
}
foreach (var c in Cells.Flatten())
{
yield return(c);
}
}
public override IEnumerable <IntVar> GetVariables(Solver solver)
{
var s = solver;
Cells = new IntVar[Size, Size];
for (var i = 0; i < Size; i++)
{
for (var j = 0; j < Size; j++)
{
Cells[i, j] = s.MakeIntVar(Min, Max, $@"[{i},{j}]");
}
}
foreach (var c in Cells.Flatten())
{
yield return(c);
}
}
static void Main(string[] args)
{
var solver = new Solver("schedule_shifts");
IntVar[,] shifts = createShifts(solver);
IntVar[,] nurses = createNurses(solver);
// Set relationships between shifts and nurses.
setRelationshipBetweenNursesAndShifts(nurses, shifts, solver);
// Make assignments different on each day
assignNursesToDifferentShiftsEachDay(nurses, shifts, solver);
// Each nurse works 5 or 6 days in a week.
makeNursesWorkFiveOrSixDays(shifts, solver);
// Create works_shift variables. works_shift[(i, j)] is True if nurse
// i works shift j at least once during the week.
IntVar[,] worksShift = createWorksShift(shifts, solver);
// For each shift (other than 0), at most 2 nurses are assigned to that shift
// during the week.
makeMaxTwoNursesForShiftDuringWeek(worksShift, solver);
// If s nurses works shifts 2 or 3 on, he must also work that shift the previous
// day or the following day.
constrainShiftPattern(nurses, solver);
IntVar[] shiftsFlat = shifts.Flatten();
// Create the decision builder.
var db = solver.MakePhase(shiftsFlat,
Solver.CHOOSE_FIRST_UNBOUND,
Solver.ASSIGN_MIN_VALUE);
var solution = solver.MakeAssignment();
solution.Add(shiftsFlat);
findSolutions(solution, solver, db, shifts);
Console.ReadKey();
}
private void PrintSodoku(IntVar[,] currentSolution, int counter)
{
Console.WriteLine("Solution " + counter + ":");
// Top Line
Console.WriteLine(" ╔═══════════╦═══════════╦═══════════╗");
// Field
for (int row = 0; row < 9; row++)
{
Console.Write(" ║ ");
for (int column = 0; column < 9; column++)
{
Console.Write("{0}", currentSolution[row, column].Value());
if ((column + 1) % 3 == 0)
{
Console.Write(" ║ ");
}
else
{
Console.Write(" │ ");
}
}
if ((row == 2) || (row == 5))
{
Console.WriteLine("\n ╠═══════════╬═══════════╬═══════════╣");
}
else
{
if (row != 8)
{
Console.WriteLine("\n ║───┼───┼───║───┼───┼───║───┼───┼───║");
}
}
}
// Bottom Line
Console.WriteLine("\n ╚═══════════╩═══════════╩═══════════╝");
}
//
// Partition the sets (binary matrix representation).
//
public static void partition_sets(Solver solver, IntVar[,] x, int num_sets, int n)
{
for (int i = 0; i < num_sets; i++)
{
for (int j = 0; j < num_sets; j++)
{
if (i != j)
{
// b = solver.Sum([x[i,k]*x[j,k] for k in range(n)]);
// solver.Add(b == 0);
solver.Add((from k in Enumerable.Range(0, n) select(x[i, k] * x[j, k])).ToArray().Sum() == 0);
}
}
}
// ensure that all integers is in
// (exactly) one partition
solver.Add(
(from i in Enumerable.Range(0, num_sets) from j in Enumerable.Range(0, n) select x[i, j]).ToArray().Sum() ==
n);
}
private void printField(IntVar[,] currentSolution)
{
Console.WriteLine("Possible solution:\n");
string tempString;
for (int row = 0; row < this.size; row++)
{
for (int column = 0; column < this.size; column++)
{
switch (currentSolution[row, column].Value())
{
case -1:
tempString = "X";
break;
case 0:
// Make a short comparison with the initial field to keep the zero value
if (this.initialField[row, column] == 0)
{
tempString = "0";
}
else
{
tempString = " ";
}
break;
default:
tempString = this.initialField[row, column].ToString();
break;
}
Console.Write(" {0}", tempString);
}
Console.Write("\n");
}
Console.WriteLine();
}
public static void Solve(int sideLength)
{
var solver = new Solver("Magic Square");
IEnumerable <int> range = Enumerable.Range(0, sideLength);
IntVar[,] square = solver.MakeIntVarMatrix(sideLength, sideLength, 1, sideLength * sideLength);
IntVar sum = solver.MakeIntVar(1, sideLength * sideLength * sideLength);
// Add constraints
// All different numbers
solver.Add(square.Flatten().AllDifferent());
foreach (var i in range)
{
// Rows should all have the same sum
solver.Add((from j in range select square[i, j]).ToArray().Sum() == sum);
// Columns should also all have the same sum
solver.Add((from j in range select square[j, i]).ToArray().Sum() == sum);
}
// Diagonals should also both have the same sum
solver.Add((from j in range select square[j, j]).ToArray().Sum() == sum);
solver.Add((from j in range select square[j, sideLength - 1 - j]).ToArray().Sum() == sum);
DecisionBuilder decisionBuilder =
solver.MakePhase(square.Flatten(), Solver.INT_VAR_SIMPLE, Solver.INT_VALUE_SIMPLE);
solver.NewSearch(decisionBuilder);
while (solver.NextSolution())
{
PrintSolution(square);
Console.WriteLine("Magic square constant: " + sum.Value());
Console.Write("\n");
}
Console.WriteLine("Finished printing solutions");
Console.WriteLine("Time: " + solver.WallTime());
Console.WriteLine("Solutions: " + solver.Solutions());
solver.EndSearch();
}
private static IntVar[,] createWorksShift(IntVar[,] shifts, Solver solver)
{
IntVar[,] worksShift = new IntVar[numberNurses, numberShifts];
for (int n = 0; n < numberNurses; n++)
{
for (int s = 0; s < numberShifts; s++)
{
worksShift[n, s] = solver.MakeBoolVar($"shift{s} nurse{n}");
IntVar[] b = new IntVar[numberDays];
for (int d = 0; d < numberDays; d++)
{
b[d] = (shifts[n, d] == s).Var();
}
solver.Add(worksShift[n, s] == solver.MakeMax(b));
}
}
return(worksShift);
}
/**
*
* Magic squares and cards problem.
*
* Martin Gardner (July 1971)
* """
* Allowing duplicates values, what is the largest constant sum for an order-3
* magic square that can be formed with nine cards from the deck.
* """
*
*
* Also see http://www.hakank.org/or-tools/magic_square_and_cards.py
*
*/
private static void Solve(int n = 3)
{
Solver solver = new Solver("MagicSquareAndCards");
IEnumerable <int> RANGE = Enumerable.Range(0, n);
//
// Decision variables
//
IntVar[,] x = solver.MakeIntVarMatrix(n, n, 1, 13, "x");
IntVar[] x_flat = x.Flatten();
IntVar s = solver.MakeIntVar(1, 13 * 4, "s");
IntVar[] counts = solver.MakeIntVarArray(14, 0, 4, "counts");
//
// Constraints
//
solver.Add(x_flat.Distribute(counts));
// the standard magic square constraints (sans all_different)
foreach (int i in RANGE)
{
// rows
solver.Add((from j in RANGE select x[i, j]).ToArray().Sum() == s);
// columns
solver.Add((from j in RANGE select x[j, i]).ToArray().Sum() == s);
}
// diagonals
solver.Add((from i in RANGE select x[i, i]).ToArray().Sum() == s);
solver.Add((from i in RANGE select x[i, n - i - 1]).ToArray().Sum() == s);
// redundant constraint
solver.Add(counts.Sum() == n * n);
//
// Objective
//
OptimizeVar obj = s.Maximize(1);
//
// Search
//
DecisionBuilder db = solver.MakePhase(x_flat, Solver.CHOOSE_FIRST_UNBOUND, Solver.ASSIGN_MAX_VALUE);
solver.NewSearch(db, obj);
while (solver.NextSolution())
{
Console.WriteLine("s: {0}", s.Value());
Console.Write("counts:");
for (int i = 0; i < 14; i++)
{
Console.Write(counts[i].Value() + " ");
}
Console.WriteLine();
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
Console.Write(x[i, j].Value() + " ");
}
Console.WriteLine();
}
Console.WriteLine();
}
Console.WriteLine("\nSolutions: {0}", solver.Solutions());
Console.WriteLine("WallTime: {0}ms", solver.WallTime());
Console.WriteLine("Failures: {0}", solver.Failures());
Console.WriteLine("Branches: {0} ", solver.Branches());
solver.EndSearch();
}
/**
*
* Solves the Magic Square problem.
* See http://www.hakank.org/or-tools/magic_square.py
*
*/
private static void Solve(int n = 4, int num = 0, int print = 1)
{
Solver solver = new Solver("MagicSquare");
Console.WriteLine("n: {0}", n);
//
// Decision variables
//
IntVar[,] x = solver.MakeIntVarMatrix(n, n, 1, n * n, "x");
// for the branching
IntVar[] x_flat = x.Flatten();
//
// Constraints
//
long s = (n * (n * n + 1)) / 2;
Console.WriteLine("s: " + s);
IntVar[] diag1 = new IntVar[n];
IntVar[] diag2 = new IntVar[n];
for (int i = 0; i < n; i++)
{
IntVar[] row = new IntVar[n];
for (int j = 0; j < n; j++)
{
row[j] = x[i, j];
}
// sum row to s
solver.Add(row.Sum() == s);
diag1[i] = x[i, i];
diag2[i] = x[i, n - i - 1];
}
// sum diagonals to s
solver.Add(diag1.Sum() == s);
solver.Add(diag2.Sum() == s);
// sum columns to s
for (int j = 0; j < n; j++)
{
IntVar[] col = new IntVar[n];
for (int i = 0; i < n; i++)
{
col[i] = x[i, j];
}
solver.Add(col.Sum() == s);
}
// all are different
solver.Add(x_flat.AllDifferent());
// symmetry breaking: upper left is 1
// solver.Add(x[0,0] == 1);
//
// Search
//
DecisionBuilder db =
solver.MakePhase(x_flat, Solver.CHOOSE_FIRST_UNBOUND, Solver.ASSIGN_CENTER_VALUE);
solver.NewSearch(db);
int c = 0;
while (solver.NextSolution())
{
if (print != 0)
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
Console.Write(x[i, j].Value() + " ");
}
Console.WriteLine();
}
Console.WriteLine();
}
c++;
if (num > 0 && c >= num)
{
break;
}
}
Console.WriteLine("\nSolutions: {0}", solver.Solutions());
Console.WriteLine("WallTime: {0}ms", solver.WallTime());
Console.WriteLine("Failures: {0}", solver.Failures());
Console.WriteLine("Branches: {0} ", solver.Branches());
solver.EndSearch();
}