private void CalculQuestion4_Click(object sender, EventArgs e)
{
string etape = this.etapeLaiterieRetour.Text;
Regex myRegex = new Regex("(,)");
etape = myRegex.Replace(etape, "");
//N*N-1 Génération de parcours
List<char> listeChar = new List<char>();
List<String> ListesChemins = new List<string>();
List<String> etapesList = new List<string>();
foreach (char lettre in etape)
{
etapesList.Add(lettre.ToString());
listeChar.Add(lettre);
}
#region Calcul d'une heuristique avec glouton
/**Calcul rapide d'une heuristique en utilisant un algoithme glouton**/
NodeGraph depart = new NodeGraph("A");
depart.setMatrice(matriceAdjacente);
double poidsMin = int.MaxValue;
List<GenericNode> SolutionEtape = new List<GenericNode>();
string EtapeName = "A";
List<GenericNode> Solution = new List<GenericNode>();
Graph Graphe = new Graph();
int cptGlouton = 0;
while (etapesList.Count != 0)
{
foreach (String nodeName in etapesList)
{
depart.setEndNode(nodeName);
List<GenericNode> SolutionTmp = Graphe.RechercheSolutionAEtoile(depart);
if (poidsMin > CalculPoids(SolutionTmp))
{
EtapeName = nodeName;
poidsMin = CalculPoids(SolutionTmp);
SolutionEtape = SolutionTmp;
}
}
poidsMin = int.MaxValue;
foreach (GenericNode Gn in SolutionEtape)
{
if (Solution.Count != 0)
{
if (Solution.Last().GetNom() != Gn.GetNom())
{
Solution.Add(Gn);
if (Gn.GetNom() == "A")
{
cptGlouton = 0;
}
}
}
else
Solution.Add(Gn);
}
cptGlouton++;
//MessageBox.Show(cptGlouton.ToString());
if (cptGlouton == 4)
{
depart = new NodeGraph(EtapeName);
depart.setEndNode("A");
List<GenericNode> RetourA = Graphe.RechercheSolutionAEtoile(depart);
foreach (GenericNode Gn in RetourA)
{
if (Solution.Count != 0)
{
if (Solution.Last().GetNom() != Gn.GetNom())
{
Solution.Add(Gn);
}
}
else
Solution.Add(Gn);
}
cptGlouton = 0;
depart = new NodeGraph("A");
etapesList.Remove(EtapeName);
}
else
{
depart = new NodeGraph(EtapeName);
etapesList.Remove(EtapeName);
}
}
NodeGraph retourDepart = new NodeGraph(Solution.Last().GetNom());
retourDepart.setEndNode("A");
SolutionEtape = Graphe.RechercheSolutionAEtoile(retourDepart);
foreach (GenericNode Gn in SolutionEtape)
{
if (Solution.Count != 0)
{
if (Solution.Last().GetNom() != Gn.GetNom())
{
Solution.Add(Gn);
}
}
else
Solution.Add(Gn);
}
string reponse = "Le chemin est : ";
string poids = "Son poids est : ";
foreach (GenericNode Gn in Solution)
{
reponse += Gn.GetNom() + " ";
}
//MessageBox.Show(reponse + "\n" + poids + CalculPoids(Solution).ToString());
double borneMax = CalculPoids(Solution);
#endregion
#region Algorithme du voyageur du commerce avec retour
GraphVoyageur Voyageur = new GraphVoyageur();
MethodeRecursive("", listeChar, ListesChemins);
List<GenericNode> SolutionOptimale = new List<GenericNode>();
double poidsVoyageur = int.MaxValue;
double poidsCourant = 0;
foreach (string combinaison in ListesChemins)
{
List<String> CheminVoyageur = new List<string>();
int cptStandart = 0;
List<GenericNode> SolutionTmp = new List<GenericNode>();
List<GenericNode> SolutionEtapeVoyageur = new List<GenericNode>();
foreach (char etapeVoyageur in combinaison)
{
CheminVoyageur.Add(etapeVoyageur.ToString());
}
NodeGraph departVoyageur = new NodeGraph("A", poidsCourant);
departVoyageur.setBorneMax((int)borneMax);
bool fin = true;
List<String> aIgnore = new List<string>();
foreach (String nodeName in CheminVoyageur)
{
if (!aIgnore.Contains(nodeName))
{
double poidsTemp = CalculPoids(SolutionTmp);
if (poidsTemp < borneMax && fin != false)
{
cptStandart++;
departVoyageur.setEndNode(nodeName);
SolutionEtapeVoyageur = Voyageur.RechercheSolutionAEtoile(departVoyageur);
foreach (GenericNode Gn in SolutionEtapeVoyageur)
{
if (nodeName.Contains(Gn.GetNom()) && cptStandart != 4)
{
cptStandart++;
aIgnore.Add(nodeName);
}
if (SolutionTmp.Count != 0)
{
if (SolutionTmp.Last().GetNom() != Gn.GetNom())
{
SolutionTmp.Add(Gn);
}
}
else
SolutionTmp.Add(Gn);
}
if (cptStandart == 4)
{
poidsCourant = CalculPoids(SolutionTmp);
departVoyageur = new NodeGraph(nodeName, poidsCourant);
departVoyageur.setEndNode("A");
List <GenericNode> SolutionRetourA = Voyageur.RechercheSolutionAEtoile(departVoyageur);
foreach (GenericNode Gn in SolutionRetourA)
{
if (SolutionTmp.Count != 0)
{
if (SolutionTmp.Last().GetNom() != Gn.GetNom())
{
SolutionTmp.Add(Gn);
}
}
else
SolutionTmp.Add(Gn);
}
cptStandart = 0;
poidsCourant = CalculPoids(SolutionTmp);
departVoyageur = new NodeGraph("A", poidsCourant);
}
else
{
poidsCourant = CalculPoids(SolutionTmp);
departVoyageur = new NodeGraph(nodeName, poidsCourant);
}
if (SolutionEtapeVoyageur.Count == 0)
{
fin = false;
SolutionTmp.Clear();
}
}
}
}
departVoyageur.setEndNode("A");
SolutionEtapeVoyageur = Voyageur.RechercheSolutionAEtoile(departVoyageur);
foreach (GenericNode Gn in SolutionEtapeVoyageur)
{
if (SolutionTmp.Count != 0)
{
if (SolutionTmp.Last().GetNom() != Gn.GetNom())
{
SolutionTmp.Add(Gn);
}
}
else
SolutionTmp.Add(Gn);
}
if (poidsVoyageur > CalculPoids(SolutionTmp))
{
poidsVoyageur = CalculPoids(SolutionTmp);
SolutionOptimale = SolutionTmp;
}
}
string reponseOptimale = "Le chemin optimal est : ";
string poidsOptimal = "Son poids est : ";
foreach (GenericNode Gn in SolutionOptimale)
{
reponseOptimale += Gn.GetNom() + " ";
}
MessageBox.Show(reponseOptimale + "\n" + poidsOptimal + CalculPoids(SolutionOptimale).ToString());
#endregion
}
private void Chemin_Click(object sender, EventArgs e)
{
NodeGraph depart = new NodeGraph(Depart.Text[0].ToString().ToUpper());
depart.setMatrice(matriceAdjacente);
NodeGraph arrive = new NodeGraph(Arrive.Text[0].ToString().ToUpper());
depart.setEndNode(arrive.GetNom());
Graph g = new Graph();
List<GenericNode> Solution = g.RechercheSolutionAEtoile(depart);
string reponse = "Le chemin est : ";
string poids = "Son poids est : ";
foreach (GenericNode Gn in Solution)
{
reponse += Gn.GetNom() + " ";
}
MessageBox.Show(reponse + "\n" + poids + CalculPoids(Solution).ToString());
g.GetSearchTree(arbre);
}
private int[,] matriceEtape(List<string> etapesList)
{
etapesList.Insert(0, "A");
int taille = etapesList.Count;
int[,] matriceLaiterie = new int[taille, taille];
for (int i = 0; i < taille; i++)
{
for (int j = 0; j < taille; j++)
{
if (i != j)
{
NodeGraph depart = new NodeGraph((etapesList[i]));
depart.setMatrice(matriceAdjacente);
Graph Graphe = new Graph();
depart.setEndNode(etapesList[j]);
List<GenericNode> SolutionTmp = Graphe.RechercheSolutionAEtoile(depart);
matriceLaiterie[i, j] = Convert.ToInt32(CalculPoids(SolutionTmp));
}
else
{
matriceLaiterie[i, j] = -1;
}
}
}
return matriceLaiterie;
}