// Méthodes abstrates, donc à surcharger obligatoirement avec override dans une classe fille public abstract bool IsEqual(GenericNode N2);
protected List <GenericNode> Enfants; // noeuds enfants
public GenericNode()
{
ParentNode = null;
Enfants = new List <GenericNode>();
}
public void SetNoeud_Parent(GenericNode g)
{
ParentNode = g;
g.Enfants.Add(this);
}
public abstract double GetArcCost(GenericNode N2);
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 List <GenericNode> RechercheSolutionAEtoile(GenericNode N0)
{
L_Ouverts = new List <GenericNode>();
L_Fermes = new List <GenericNode>();
ListeOuverts = new string[50]; //Voir si on ne peut pas faire un tableau de la taille exacte du nombre de n°/noeuds !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
ListeFermes = new string[50]; // Liste des fermés enregistrés à chaque étape
// 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
//int etapeDij = 0; //(Nb. détapes - 1) de la résolution de A*
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 et les mettre dans le ouverts
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;
}
//Enregistrement des étapes de recherche de F et O à chaque fois :
for (int i = 0; i < L_Fermes.Count; i++)
{
ListeFermes[etapeDij] += Convert.ToString(L_Fermes[i]);
}
for (int i = 0; i < L_Ouverts.Count; i++)
{
ListeOuverts[etapeDij] += Convert.ToString(L_Ouverts[i]);
}
etapeDij++;
}
if (N.EndState() == true) //Dernière étape
{
L_Ouverts.Remove(N);
L_Fermes.Add(N);
//Enregistrement de la dernière étapes pour F et O :
for (int i = 0; i < L_Fermes.Count; i++)
{
ListeFermes[etapeDij] += Convert.ToString(L_Fermes[i]);
}
ListeOuverts[etapeDij] += "vide";
etapeDij++;
}
// 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); //seulement le n° des noeuds faisant partis du + court chemin
}
//il faut que ça rende true si à l'etape concernée les ouverts et les fermés donné par l'utilisateur sont les bons
public bool RechercheSolutionAEtoileValidation(GenericNode N0, int etapeValidation, string ouvertDonne, string fermeDonne)
{
int etape = 0;
L_Ouverts = new List <GenericNode>();
L_Fermes = new List <GenericNode>();
string ouvertCorrection = "";
string fermeCorrection = "";
// 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)
{
foreach (GenericNode x in L_Ouverts)
{
ouvertCorrection += x.ToString();
}
if (L_Fermes.Count != 0)
{
foreach (GenericNode x in L_Fermes)
{
fermeCorrection += x.ToString();
}
}
if ((etape == etapeValidation) && etudeString(ouvertCorrection, ouvertDonne) && etudeString(fermeCorrection, fermeDonne))
{
return(true);
}
/* Si à l'étape que l'on corrige, les ouvert et les fermés donnés sont les mêmes que les ouverts et les fermés trouvés par A* alors on retourne true.
* Sinon on retourne false : l'utilisateur c'est trompé !
*/
// 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;
}
// Il faut ensuite nettoyer les string ouvertCorrection et fermeCorrection pour les étapes suivantes:
ouvertCorrection = "";
fermeCorrection = "";
etape++;
}
return(false); // Si on sort de la boucle while c'est que l'utilisateur c'est trompé
}