/// <summary>
/// Retourne une solution par la méthode des plus prches voisins
/// </summary>
/// <param name="parser">DataParser à utiliser</param>
/// <param name="loadConstraint">Contrainte de chargement</param>
/// <returns>Solution générée</returns>
public static CVRPSolution PPVSolution(DataParser parser, double loadConstraint)
{
CVRPSolution sol = _AddVars(parser); //Génère une instance de la solution
sol.addNewRoute(parser); //Créé une nouvelle route
sol.setVariable(0, parser, loadConstraint); //Fixe le dépot dans la route
double[,] arcWeight = (double[, ])parser.arcWeight.Clone(); //Créé une copie de la matrice des distance
//On boucle tant que tout les clients ne sont pas servis
while (sol.freeVarCount != 0)
{
int nearestId = 0; //On initialise le plus proche voisin
double distance = arcWeight[sol.varsIdList[sol.varsIdList.Count - 1], 0]; //On initialise sa distance au dernier point visité
//On parcours tout les voisins potentiels
for (int j = 1; j < parser.nodeList.Count; j++)
{
//Si l'arc vers j est réalisable et meilleur que les précédents considérés
if (arcWeight[sol.varsIdList[sol.varsIdList.Count - 1], j] != 0 && (distance == 0 || arcWeight[sol.varsIdList[sol.varsIdList.Count - 1], j] < distance))
{
//On met à jour le plus prche voisin
nearestId = j;
distance = arcWeight[sol.varsIdList[sol.varsIdList.Count - 1], j];
}
}
//Si on revient au dépot, on créé une nouvelle solution
if (nearestId == 0)
{
sol.endRoute();
}
else
{
sol.setVariable(nearestId, parser, loadConstraint); //On fixe le plus proche voisin
}
//On empêche le plus proche voisin d'être de nouveau disponible
for (int j = 0; j < parser.nodeList.Count; j++)
{
arcWeight[j, nearestId] = 0;
}
}
sol.endSolution(); //On termine la solution
return(sol);
}
/// <summary>
/// Retourne une solution par ordre d'apparition dans le fichier
/// </summary>
/// <param name="parser">DataParser à utiliser</param>
/// <param name="loadConstraint">Contrainte de chargement</param>
/// <returns>Solution générée</returns>
public static CVRPSolution OrderedSolution(DataParser parser, double loadConstraint)
{
CVRPSolution sol = _AddVars(parser); //Génère une instance de la solution
sol.addNewRoute(parser); //Créé une nouvelle route
//On fixe les variables
for (int i = 0; i < parser.nodeList.Count; i++)
{
sol.setVariable(i, parser, loadConstraint);
}
sol.endSolution(); //On termine la solution
return(sol);
}
/// <summary>
/// Fonction récursive de résolution
/// </summary>
/// <param name="currentNode">Noeud courant de l'arbre</param>
/// <param name="step">Profondeur du parcours</param>
/// <returns>Noeud courant</returns>
private TreeNode solve(TreeNode currentNode, int step)
{
//Si la solution est une solution finale
if (currentNode.sol.isFinalSolution())
{
//On al déclare comme finale
((CVRPSolution)currentNode.sol).endSolution();
currentNode.sol.eval = getFixedCost((CVRPSolution)currentNode.sol);
//Si cette solution est meilleure
if (majValue > currentNode.sol.eval)
{
//On met à jour la meilleure solution et on l'affiche
majValue = currentNode.sol.eval;
bestSol = (CVRPSolution)currentNode.sol;
logger.log("Meilleur solution trouvée de coût:" + ((int)Math.Round(currentNode.sol.eval)).ToString(), Message.Level.Warning);
computedSteps++;
displaySolution(bestSol);
}
else
{
currentNode.isLocked = true; //On bloque la solution
computedSteps++;
}
updateBenchmark(step);
return(currentNode);
}
else
{
List <TreeNode> nextSol = new List <TreeNode>(); //On initialise la liste des enfants
for (int i = 0; i < _pb.varCount; i++)
{
//Pour chaque variable en encors libre
if (!currentNode.sol.isFixed(i))
{
CVRPSolution nSol1 = (CVRPSolution)currentNode.sol.copy(); //On copie la solution
nSol1.setVariable(i, data, loadConstraint); //On fixe une nouvelle variable
nSol1.eval = evaluateSolution(nSol1, step); //On détermine la borne inférieure
//Si la solution est viable
//> ou < selon minimisation ou maximisation
if (nSol1.eval <= majValue)
{
nextSol.Add(new TreeNode(nSol1, null)); //On l'ajoute aux enfants
}
else
{
computedSteps++;
}
//Si on peut obtenir une autre solution en créant une nouvelle route
if (nSol1.routes.Count == ((CVRPSolution)currentNode.sol).routes.Count)
{
CVRPSolution nSol2 = (CVRPSolution)currentNode.sol.copy();
nSol2.endRoute();
nSol2.setVariable(i, data, loadConstraint);
nSol2.eval = evaluateSolution(nSol2, step);
//> ou < selon minimisation ou maximisation
if (nSol2.eval <= majValue)
{
nextSol.Add(new TreeNode(nSol2, null));
}
else
{
computedSteps++;
}
}
}
}
//Si il y a des enfants
if (nextSol.Count != 0)
{
nextSol.Sort((x, y) => x.sol.eval.CompareTo(y.sol.eval)); //On les trie selon leur borne inférieure
//On parcours les enfants
for (int i = 0; i < nextSol.Count; i++)
{
//Si la solution est toujours viable
if (nextSol[i].sol.eval <= majValue)
{
nextSol[i] = solve(nextSol[i], step + 1); //On poursuit la résolution
}
else
{
nextSol[i].isLocked = true;
computedSteps++;
}
}
currentNode.childs = nextSol;
}
else
{
currentNode.isLocked = true;
updateBenchmark(step);
}
computedSteps++;
int locked = 0;
//On regarde si tout les enfants sont bloquéss
foreach (TreeNode node in nextSol)
{
if (node.isLocked)
{
node.Dispose();
locked++;
}
}
//Si ils le sont tous, on bloque la solution
if (locked == nextSol.Count)
{
currentNode.isLocked = true;
nextSol = null;
}
return(currentNode);
}
}
/// <summary>
/// Retourne une solution par la méthode de Clarke and Wright
/// </summary>
/// <param name="parser">DataParser à utiliser</param>
/// <param name="loadConstraint">Contrainte de chargement</param>
/// <returns>Solution générée</returns>
public static CVRPSolution ClarkeWrightSolution(DataParser parser, double loadConstraint)
{
CVRPSolution sol = _AddVars(parser); //Génère une instance de la solution
//On initialise la liste des savings
List <KeyValuePair <Tuple <int, int>, double> > savings = new List <KeyValuePair <Tuple <int, int>, double> >();
int j;
//On génère les savings
for (int i = 1; i < parser.nodeList.Count; i++)
{
for (j = 1; j < parser.nodeList.Count - 1; j++)
{
int realJ = j;
//On évite l'arc i->i
if (j >= i)
{
realJ++;
}
savings.Add(new KeyValuePair <Tuple <int, int>, double>(new Tuple <int, int>(i, realJ), parser.arcWeight[0, realJ] + parser.arcWeight[i, 0] - parser.arcWeight[i, realJ]));
}
}
//On trie la liste
savings.Sort(
delegate(KeyValuePair <Tuple <int, int>, double> pair1, KeyValuePair <Tuple <int, int>, double> pair2)
{
return(pair1.Value.CompareTo(pair2.Value));
});
savings.Reverse(); //On la renverse (ordre décroissant)
List <List <int> > routes = new List <List <int> >(); //Liste des routes de la solution
List <double> routeDist = new List <double>(); //Liste des distances associés à chaques routes
List <double> routeCosts = new List <double>(); //Liste des coûts associés à chaques routes
//On initialise les routes initiales
for (int i = 1; i < parser.nodeList.Count; i++)
{
routes.Add(new List <int>(new int[] { i }));
routeDist.Add(parser.arcWeight[0, i] + parser.arcWeight[i, 0]);
routeCosts.Add(parser.nodeList[i].quantity);
}
j = 0;
//Tant que la solution
while (j < savings.Count - 1 && savings[j].Value >= 0)
{
Tuple <int, int> couple = savings[j].Key; //On récupère les noeuds associés au saving
//On vérifie que les deux noeuds peuvent être fusionnés
object[] res = _areMergeable(couple.Item1, couple.Item2, routes, routeDist, routeCosts, savings[j].Value, loadConstraint);
//Si ils peuvent être fusionné
if ((bool)res[0])
{
routes[(int)res[1]] = routes[(int)res[1]].Concat(routes[(int)res[2]]).ToList(); //On créé la nouvelle route
routeDist[(int)res[1]] = (double)res[4]; //On met à jour la distance de la route
routeCosts[(int)res[1]] = (double)res[3]; //On met à jour le coût de la route
routes.RemoveAt((int)res[2]); //On suppprime l'ancienne route
routeDist.RemoveAt((int)res[2]);
routeCosts.RemoveAt((int)res[2]); //On supprime le coût associé
}
j++;
}
//On créé la solution
foreach (List <int> r in routes)
{
sol.addNewRoute(parser);
foreach (int node in r)
{
sol.setVariable(node, parser, loadConstraint);
}
sol.endSolution();
}
return(sol);
}