public void Solve(GrilleSudoku s)
{
//conversion de formats en int[,]
int[,] converted = new int[9, 9];
for (int row = 0; row < 9; row++)
{
for (int column = 0; column < 9; column++)
{
converted[row, column] = s.Cellules[row * 9 + column];
}
}
var sudoku = Sudoku.New(converted);
var solver = new SudokuSolver();
var solvedSudoku = solver.Solve(sudoku, 200, 5000, 40);
// Possibilité d'incrémenter le nombre d'organismes jusqu'à obtenir une solution?
// Mais les meilleures optimisations à faire sont probablement dans le code du solver lui-même, auquel cas, il faudrait copier le code dans le projet plutôt que le référencer
var numOrganisms = 200;
do
{
solvedSudoku = solver.Solve(sudoku, numOrganisms, 5000, 1);
numOrganisms *= 2;
} while (solvedSudoku.Error > 0);
//affichage du sudoku
Console.WriteLine(solvedSudoku.ToString());
//Reconversion depuis int[,]
for (int row = 0; row < 9; row++)
{
for (int column = 0; column < 9; column++)
{
s.Cellules[row * 9 + column] = solvedSudoku.CellValues[row, column];
}
}
}
private Sudoku SolveInternal(Sudoku sudoku, int numOrganisms, int maxEpochs)
{
var numberOfWorkers = (int)(numOrganisms * 0.90);
//hive, la collection d'organismes.
var hive = new Organism[numOrganisms];
var bestError = int.MaxValue;
Sudoku bestSolution = null;
for (var i = 0; i < numOrganisms; ++i)
{
var organismType = i < numberOfWorkers
? OrganismType.Worker
: OrganismType.Explorer;
//Pour le SWARM, nous initialisation une matrice a une solution possible aleatoire
var randomSudoku = Sudoku.New(MatrixHelper.RandomMatrix(_rnd, sudoku.CellValues));
var err = randomSudoku.Error;
hive[i] = new Organism(organismType, randomSudoku.CellValues, err, 0);
if (err >= bestError)
{
continue;
}
bestError = err;
bestSolution = Sudoku.New(randomSudoku);
}
var epoch = 0;
while (epoch < maxEpochs)
{
if (epoch % 1000 == 0)
{
Console.WriteLine($"Epoch: {epoch}, Best error: {bestError}");
}
if (bestError == 0)
{
break;
}
for (var i = 0; i < numOrganisms; ++i)
{
if (hive[i].Type == OrganismType.Worker)
{
// il existe plusieurs type d'organisme : celles sertvant a l'exploration de solutions aleatoire,
//et les organismes analysant les voisins
var neighbor = MatrixHelper.NeighborMatrix(_rnd, sudoku.CellValues, hive[i].Matrix);
var neighborSudoku = Sudoku.New(neighbor);
var neighborError = neighborSudoku.Error;
var p = _rnd.NextDouble();
if (neighborError < hive[i].Error || p < 0.001)
{
hive[i].Matrix = MatrixHelper.DuplicateMatrix(neighbor);
hive[i].Error = neighborError;
if (neighborError < hive[i].Error)
{
hive[i].Age = 0;
}
if (neighborError >= bestError)
{
continue;
}
bestError = neighborError;
bestSolution = neighborSudoku;
}
else
{
hive[i].Age++;
if (hive[i].Age <= 1000)
{
continue;
}
var randomSudoku = Sudoku.New(MatrixHelper.RandomMatrix(_rnd, sudoku.CellValues));
hive[i] = new Organism(0, randomSudoku.CellValues, randomSudoku.Error, 0);
}
}
else
{
var randomSudoku = Sudoku.New(MatrixHelper.RandomMatrix(_rnd, sudoku.CellValues));
hive[i].Matrix = MatrixHelper.DuplicateMatrix(randomSudoku.CellValues);
hive[i].Error = randomSudoku.Error;
if (hive[i].Error >= bestError)
{
continue;
}
bestError = hive[i].Error;
bestSolution = randomSudoku;
}
}
// merge best worker with best explorer into worst worker
var bestWorkerIndex = 0;
var smallestWorkerError = hive[0].Error;
for (var i = 0; i < numberOfWorkers; ++i)
{
if (hive[i].Error >= smallestWorkerError)
{
continue;
}
smallestWorkerError = hive[i].Error;
bestWorkerIndex = i;
}
var bestExplorerIndex = numberOfWorkers;
var smallestExplorerError = hive[numberOfWorkers].Error;
for (var i = numberOfWorkers; i < numOrganisms; ++i)
{
if (hive[i].Error >= smallestExplorerError)
{
continue;
}
smallestExplorerError = hive[i].Error;
bestExplorerIndex = i;
}
var worstWorkerIndex = 0;
var largestWorkerError = hive[0].Error;
for (var i = 0; i < numberOfWorkers; ++i)
{
if (hive[i].Error <= largestWorkerError)
{
continue;
}
largestWorkerError = hive[i].Error;
worstWorkerIndex = i;
}
//les blocks de bonnes solution ssont utiliser afin de creer une bonne solution enfant => en prenant deux bonnes solutions
//pour une nouvelle iteration
//cet enfant prends la place d'un mauvaise solution
var merged = MatrixHelper.MergeMatrices(_rnd, hive[bestWorkerIndex].Matrix, hive[bestExplorerIndex].Matrix);
var mergedSudoku = Sudoku.New(merged);
hive[worstWorkerIndex] = new Organism(0, merged, mergedSudoku.Error, 0);
if (hive[worstWorkerIndex].Error < bestError)
{
bestError = hive[worstWorkerIndex].Error;
bestSolution = mergedSudoku;
}
++epoch;
}
return(bestSolution);
}