public void InsertNewNodeInOpenList(GenericNode NewNode)
{
// Insertion pour respecter l'ordre du cout total le plus petit au plus grand
if (this.L_Ouverts.Count == 0)
{ L_Ouverts.Add(NewNode); }
else
{
GenericNode N = L_Ouverts[0];
bool trouve = false;
int i = 0;
do
if (NewNode.Cout_Total < N.Cout_Total)
{
L_Ouverts.Insert(i, NewNode);
trouve = true;
}
else
{
i++;
if (L_Ouverts.Count == i)
{
N = null;
L_Ouverts.Insert(i, NewNode);
}
else
{ N = L_Ouverts[i]; }
}
while ((N != null) && (trouve == false));
}
}
public override double GetArcCost(GenericNode N2)
{
int ligne = Convert.ToInt32(this.GetNom()[0]) - 65;
int colonne = Convert.ToInt32(N2.GetNom()[0]) - 65;
return Matrice[ligne,colonne];
}
public List<GenericNode> RechercheSolutionAEtoile(GenericNode N0)
{
L_Ouverts = new List<GenericNode>();
L_Fermes = new List<GenericNode>();
// Le noeud passé en paramètre est supposé être le noeud initial
GenericNode N = N0;
L_Ouverts.Add(N0);
// tant que le noeud n'est pas terminal et que ouverts n'est pas vide
while (L_Ouverts.Count != 0 && N.EndState() == false)
{
// Le meilleur noeud des ouverts est supposé placé en tête de liste
// On le place dans les fermés
L_Ouverts.Remove(N);
L_Fermes.Add(N);
// Il faut trouver les noeuds successeurs de N
this.MAJSuccesseurs(N);
// Inutile de retrier car les insertions ont été faites en respectant l'ordre
// On prend le meilleur, donc celui en position 0, pour continuer à explorer les états
// A condition qu'il existe bien sûr
if (L_Ouverts.Count > 0)
{
N = L_Ouverts[0];
}
else
{
N = null;
}
}
// A* terminé
// On retourne le chemin qui va du noeud initial au noeud final sous forme de liste
// Le chemin est retrouvé en partant du noeud final et en accédant aux parents de manière
// itérative jusqu'à ce qu'on tombe sur le noeud initial
List<GenericNode> _LN = new List<GenericNode>();
if (N != null)
{
_LN.Add(N);
while (N != N0)
{
N = N.GetNoeud_Parent();
_LN.Insert(0, N); // On insère en position 1
}
}
return _LN;
}
protected List <GenericNode> Enfants; // noeuds enfants
public GenericNode()
{
ParentNode = null;
Enfants = new List <GenericNode>();
}
/// <summary>
/// Cout de l'arc séparant le noeud courant du GenericNode genNode.
/// </summary>
/// <param name="genNode"></param>
/// <returns></returns>
public override double GetArcCost(GenericNode genNode)
{
AlphaBetNode alphaNode = (AlphaBetNode)genNode;
return(graph.AdjacentMatrix[Num, alphaNode.Num]);
}
public override bool IsEqual(GenericNode genNode)
{
AlphaBetNode alphaNode = (AlphaBetNode)genNode;
return(Num == alphaNode.Num);
}
// Méthodes abstrates, donc à surcharger obligatoirement avec override dans une classe fille public abstract double GetArcCost(GenericNode N2);
// AjouteBranche est exclusivement appelée par GetSearchTree; les noeuds sont ajoutés de manière récursive
private void AjouteBranche(GenericNode GN, TreeNode TN)
{
foreach (GenericNode GNfils in GN.GetEnfants())
{
TreeNode TNfils = new TreeNode(GNfils.GetNom());
TN.Nodes.Add(TNfils);
if (GNfils.GetEnfants().Count > 0) AjouteBranche(GNfils, TNfils);
}
}
public abstract double GetArcCost(GenericNode N2);
public void SetNoeud_Parent(GenericNode g)
{
ParentNode = g;
g.Enfants.Add(this);
}
public override double GetArcCost(GenericNode N2)
{
Cell N2Cell = (Cell)N2;
return(Math.Sqrt(Math.Pow(N2Cell.X - this.X, 2) + Math.Pow(N2Cell.Y - this.Y, 2)));
}
public override bool IsEqual(GenericNode N2)
{
Cell n2Cell = (Cell)N2;
return(X == n2Cell.X && Y == n2Cell.Y);
}
public override double GetArcCost(GenericNode N2)
{
Node2 N2bis = (Node2)N2;
return(Dijkstra.matrice[numero, N2bis.numero]);
}
// Méthodes abstrates, donc à surcharger obligatoirement avec override dans une classe fille
public override bool IsEqual(GenericNode N2)
{
Node2 N2bis = (Node2)N2;
return(numero == N2bis.numero);
}
public void SetNoeud_Parent(GenericNode g)
{
ParentNode = g;
g.Enfants.Add(this);
}
// Méthodes abstrates, donc à surcharger obligatoirement avec override dans une classe fille public abstract bool IsEqual(GenericNode N2);
public void Supprime_Liens_Parent()
{
if (ParentNode == null) return;
ParentNode.Enfants.Remove(this);
ParentNode = null;
}
public GenericNode(string nom)
{
Name = nom.ToUpper();
ParentNode = null;
Enfants = new List<GenericNode>();
}
protected void MAJSuccesseurs(GenericNode N)
{
// On fait appel à GetListSucc, méthode abstraite qu'on doit réécrire pour chaque
// problème. Elle doit retourner la liste complète des noeuds successeurs de N.
List<GenericNode> listsucc = N.GetListSucc();
foreach (GenericNode N2 in listsucc)
{
// N2 est-il une copie d'un nœud déjà vu et placé dans la liste des fermés ?
GenericNode N2bis = ChercheNodeDansFermes(N2.GetNom());
if (N2bis == null)
{
// Rien dans les fermés. Est-il dans les ouverts ?
N2bis = ChercheNodeDansOuverts(N2.GetNom());
if (N2bis != null)
{
// Il existe, donc on l'a déjà vu, N2 n'est qu'une copie de N2Bis
// Le nouveau chemin passant par N est-il meilleur ?
if (N.Cout_Total + N.GetArcCost(N2) < N2bis.Cout_Total)
{
// Mise à jour de N2bis
N2bis.SetGCost(N.GetGCost() + N.GetArcCost(N2));
// HCost pas recalculé car toujours bon
N2bis.calculCoutTotal(); // somme de GCost et HCost
// Mise à jour de la famille ....
N2bis.Supprime_Liens_Parent();
N2bis.SetNoeud_Parent(N);
// Mise à jour des ouverts
L_Ouverts.Remove(N2bis);
this.InsertNewNodeInOpenList(N2bis);
}
// else on ne fait rien, car le nouveau chemin est moins bon
}
else
{
// N2 est nouveau, MAJ et insertion dans les ouverts
N2.SetNoeud_Parent(N);
N2.SetGCost(N.GetGCost() + N.GetArcCost(N2));
N2.CalculeHCost();
N2.calculCoutTotal(); // somme de GCost et HCost
this.InsertNewNodeInOpenList(N2);
}
}
// else il est dans les fermés donc on ne fait rien,
// car on a déjà trouvé le plus court chemin pour aller en N2
}
}
