public ISolution RandomSolution()
{
KnapsackSolution solution = new KnapsackSolution(); // creation d'une liste de box : loadedContent.
List <Box> possibleBoxes = boxes; // Liste de boxes disponibles.
double enableSpace = MaxWeight; // Espace disponibles.
List <Box> availableBoxes = possibleBoxes.Where(x => (x.Weight <= enableSpace)).ToList();
// on tire au sort des boîtes une à une parmi les boîtes disponibles.
// Trie : tous les boxes de possibleBoxes dont le poids est inferieur ou egale à enableSpace.
while (enableSpace > 0 && availableBoxes.Count != 0)
{ // Pour s’assurer qu’il s’agit d’une solution viable, on vérifie que l’espace disponible est suffisant.
int index = randomGenerator.Next(0, availableBoxes.Count);
solution.LoadedContent.Add(availableBoxes.ElementAt(index));
enableSpace = MaxWeight - solution.Weight;
// enableSpace diminue au fur et a mesure que l'on ajoute des box dans la solution.
availableBoxes = possibleBoxes.Except(solution.LoadedContent).Where(x => (x.Weight <= enableSpace)).ToList();
// On tire au sort des boîtes une à une parmi les boîtes disponibles et non encore utilisées.
/* Trie : tous les boxes de possibleBoxes dont le poids est inferieur ou egale à enableSpace
* et pas contenu dans solution.LoadedContent.*/
}
return(solution);
}
protected override void UpdateSolutions() // Consiste à mettre à jour les différentes solutions.
{
List <Box> possibleBoxes = ((KnapsackProblem)pb).Boxes();
foreach (ISolution genericSolution in currentSolutions)
{ // On parcoure la liste de toute la population de solutions.
KnapsackSolution solution = (KnapsackSolution)genericSolution;
if (!solution.Equals(bestSoFarSolution))
{ /*Pour chacune, s’il ne s’agit pas de la meilleure trouvée jusqu’à présent, on va lui ajouter
* un élément de cette dernière, et un élément de la meilleure de la population actuelle.
* Les éléments tirés au sort ne sont ajoutés que s’ils ne sont pas déjà présents dans le sac à dos.*/
//On recupere aleatoirement un element contenu dans bestActualSolution.
int index = KnapsackProblem.randomGenerator.Next(0, ((KnapsackSolution)bestActualSolution).LoadedContent.Count);
Box element = ((KnapsackSolution)bestActualSolution).LoadedContent.ElementAt(index);
if (!solution.LoadedContent.Contains(element))
{ // On s'assure que la nouvelle solution ne contient pas deja Box element.
solution.LoadedContent.Add(element);
}
//On recupere aleatoirement un element contenu dans bestSoFarSolution.
index = KnapsackProblem.randomGenerator.Next(0, ((KnapsackSolution)bestSoFarSolution).LoadedContent.Count);
element = ((KnapsackSolution)bestSoFarSolution).LoadedContent.ElementAt(index);
if (!solution.LoadedContent.Contains(element))
{
solution.LoadedContent.Add(element);
}
while (solution.Weight > ((KnapsackProblem)pb).MaxWeight)
{
/*Après cet ajout, le sac peut avoir un poids trop important. On élimine alors
* aléatoirement des boîtes jusqu’à repasser sous la limite du poids.*/
index = KnapsackProblem.randomGenerator.Next(0, solution.LoadedContent.Count);
solution.LoadedContent.RemoveAt(index);
}
double enableSpace = ((KnapsackProblem)pb).MaxWeight - solution.Weight;
// On calcule l'espace disponible dans le sac.
List <Box> availableBoxes = possibleBoxes.Except(solution.LoadedContent).Where(x => (x.Weight <= enableSpace)).ToList();
/* Trie : Toutes les boxes contenus dans possibleBoxes a l'exception des boxes déja contenu
* dans la soution et dont le poids est inferieur ou egale a l'espace disponible.*/
while (enableSpace > 0 && availableBoxes.Count != 0)
{
// Ajout d'un element de availableBoxes tiré au hazard dans la solution.
index = KnapsackProblem.randomGenerator.Next(0, availableBoxes.Count);
solution.LoadedContent.Add(availableBoxes.ElementAt(index));
enableSpace = ((KnapsackProblem)pb).MaxWeight - solution.Weight;
availableBoxes = possibleBoxes.Except(solution.LoadedContent).Where(x => (x.Weight <= enableSpace)).ToList();
}
}
}
}
KnapsackSolution solution; // Reference de la solution.
protected override void ConstructSolution() // Constrution de la solution.
{
KnapsackProblem problem = (KnapsackProblem)pb; // Probleme pb passer en parametre.
List <Box> boxes = problem.Boxes(); // Liste de boxes du probleme pb.
solution = new KnapsackSolution(); // Creation de la solution (loadedContent = new List<Box> ()).
foreach (Box currentBox in boxes.OrderByDescending(x => x.Value / x.Weight))
{
// L'on classe les boxes par ordre decroissant (Valeur/Kg).
double spaceLeft = problem.MaxWeight - solution.Weight;
// On evalue a chaque tour de boucle la valeur de l'espace disponible.
if (currentBox.Weight < spaceLeft)
{
// S'il y a encore de l'espace on ajout le box.
solution.LoadedContent.Add(currentBox);
}
}
}
public override bool Equals(object _object) // Comparaison de deux solutions.
{
KnapsackSolution solution = (KnapsackSolution)_object;
if (solution.loadedContent.Count != loadedContent.Count || solution.Value != Value || solution.Weight != Weight)
{
// Si Nombre de box différent | Valeur differente | Poids différent.
return(false);
}
else
{
foreach (Box box in loadedContent)
{
if (!solution.loadedContent.Contains(box))
{
// On teste alors si chaque boîte contenue dans le premier sac à dos se retrouve dans le deuxième.
return(false);
}
}
}
return(true);
}
public List <ISolution> Neighbourhood(ISolution _currentSolution)
{
List <ISolution> neighbours = new List <ISolution>();
List <Box> possibleBoxes = boxes;
for (int i = 0; i < NB_NEIGHBOURS; i++) // Creation du voisinage.
{
KnapsackSolution newSol = new KnapsackSolution((KnapsackSolution)_currentSolution);
// On recupere la solution courante : Base d'une solution du voisinage.
int index = randomGenerator.Next(0, newSol.LoadedContent.Count);
// On recupere l'index : position d'une box de la solution en cours de création.
newSol.LoadedContent.RemoveAt(index);
// On retire la boxe de la solution.
double enableSpace = MaxWeight - newSol.Weight; // Poids disponible dans la solution.
List <Box> availableBoxes = possibleBoxes.Except(newSol.LoadedContent).Where(x => (x.Weight <= enableSpace)).ToList();
/* Trie : tous les boxes de possibleBoxes dont le poids est inferieur ou egale à enableSpace
* et pas contenu dans newSol.LoadedContent.*/
while (enableSpace > 0 && availableBoxes.Count != 0)
{// A chaque itération.
index = randomGenerator.Next(0, availableBoxes.Count);
// On recupere l'index : position aleatoire d'une boxe de availableBoxes.
newSol.LoadedContent.Add(availableBoxes.ElementAt(index));
// Ajout de la boite placé a cette position dans newSol.
enableSpace = MaxWeight - newSol.Weight;
// Réevaluation de l'espace disponible.
availableBoxes = possibleBoxes.Except(newSol.LoadedContent).Where(x => (x.Weight <= enableSpace)).ToList();
/* Trie : tous les boxes de possibleBoxes dont le poids est inferieur ou egale à enableSpace
* et pas contenu dans newSol.LoadedContent.*/
}
neighbours.Add(newSol); // Ajout du voisin crée dans la liste des voisins.
}
return(neighbours);
}
public KnapsackSolution(KnapsackSolution _solution)
{
// Constructeur qui copie le contenu de la solution passée en paramètre.
loadedContent = new List <Box>();
loadedContent.AddRange(_solution.loadedContent);
}
