public void Solve_BacktrackSolver_NoSolution(int n)
{
var problem = NQueens.CreateProblem(n);
var solver = new RecursiveBacktrackSolver <int, int>();
var solution = solver.Solve(problem, CancellationToken.None);
Assert.IsNull(solution);
}
public void Solve_BacktrackSolver_VariablesReverseOrder()
{
var problem = NQueens.CreateProblem();
var solver = new RecursiveBacktrackSolver <int, int>(variableSelectionStrategy: new ComparerVariableSelectionStrategy <int, int>((a, b) => b.UserObject.CompareTo(a.UserObject)));
var solution = solver.Solve(problem, CancellationToken.None);
var expected = new Dictionary <int, int>
{
{ 1, 4 }, { 2, 2 }, { 3, 7 }, { 4, 3 }, { 5, 6 }, { 6, 8 }, { 7, 5 }, { 8, 1 },
};
CollectionAssert.AreEquivalent(expected, solution.AsReadOnlyDictionary().OrderBy(kv => kv.Key.UserObject).ToDictionary(kv => kv.Key.UserObject, kv => kv.Value));
}
public void Solve_BacktrackSolver()
{
var problem = NQueens.CreateProblem();
var solver = new RecursiveBacktrackSolver <int, int>();
var solution = solver.Solve(problem, CancellationToken.None);
var expected = new Dictionary <int, int>
{
{ 1, 1 }, { 2, 5 }, { 3, 8 }, { 4, 6 }, { 5, 3 }, { 6, 7 }, { 7, 2 }, { 8, 4 },
};
CollectionAssert.AreEquivalent(expected, solution.AsReadOnlyDictionary().OrderBy(kv => kv.Key.UserObject).ToDictionary(kv => kv.Key.UserObject, kv => kv.Value));
}
public void Solve_BacktrackSolver_MinimumRemainingValueVariableSelectionStrategy()
{
var problem = NQueens.CreateProblem();
var solver = new RecursiveBacktrackSolver <int, int>(variableSelectionStrategy: new MinimumRemainingValueVariableSelectionStrategy <int, int>());
var solution = solver.Solve(problem, CancellationToken.None);
Assert.IsNotNull(solution);
// TODO: Not always consistent, need to figure out why.
//var expected = new Dictionary<int, int>
//{
// {1, 1}, {2, 5}, {3, 8}, {4, 6}, {5, 3}, {6, 7}, {7, 2}, {8, 4},
//};
//CollectionAssert.AreEquivalent(expected, solution.AsReadOnlyDictionary().OrderBy(kv => kv.Key.UserObject).ToDictionary(kv => kv.Key.UserObject, kv => kv.Value));
}
public void Solve_BacktrackSolver()
{
var problem = MapColoring.CreateProblem(5);
var solver = new RecursiveBacktrackSolver <string, int>();
var solution = solver.Solve(problem, CancellationToken.None);
var assigned = new Dictionary <string, int>();
foreach (Variable <string, int> v in problem.Variables)
{
assigned[v.UserObject] = solution.GetValue(v);
}
var adjacencies = new Dictionary <string, List <string> > {
{ "Western Australia", new List <string> {
"Northern Territory", "South Australia"
} },
{ "Northern Territory", new List <string> {
"Western Australia", "South Australia", "Queensland"
} },
{ "New South Wales", new List <string> {
"Queensland", "South Australia", "Victoria"
} },
{ "Queensland", new List <string> {
"Northern Territory", "South Australia", "New South Wales"
} },
{ "South Australia", new List <string> {
"Western Australia", "Northern Territory", "New South Wales", "Queensland", "Victoria"
} },
{ "Victoria", new List <string> {
"New South Wales", "South Australia"
} },
{ "Tasmania", new List <string> {
} }
};
foreach (string t in adjacencies.Keys)
{
var neighbors = adjacencies[t];
foreach (string n in neighbors)
{
Assert.AreNotEqual(assigned[t], assigned[n]);
}
}
}
public void Demo()
{
const int n = 8;
IReadOnlyCollection <int> values = Enumerable.Range(1, n).ToList();
IReadOnlyCollection <Variable <string, int> > variables = Enumerable.Range(1, n).Select(i => new Variable <string, int>(i.ToString(), values)).ToList();
IConstraint <string, int>[] constraints = new[] { new AllDifferentConstraint <string, int>(variables) };
Problem <string, int> problem = new Problem <string, int>(variables, constraints);
ISolver <string, int> solver = new RecursiveBacktrackSolver <string, int>();
Assignment <string, int> solution = solver.Solve(problem, CancellationToken.None);
IReadOnlyDictionary <Variable <string, int>, int> solutionDictionary = solution.AsReadOnlyDictionary();
var expectedDictionary = Enumerable.Range(1, n).ToDictionary(i => i.ToString(), i => i);
var actualDictionary = solutionDictionary.OrderBy(kv => kv.Key.UserObject).ToDictionary(kv => kv.Key.UserObject, kv => kv.Value);
CollectionAssert.AreEqual(expectedDictionary, actualDictionary);
}
