private void button_Dijkstra_Click(object sender, EventArgs e)
{
affichageCheminListBox.Items.Clear();
commentaireTextBox.Clear();
string message = "ERREUR \r\n";
try
{
numinitial = Convert.ToInt32(noeud_debut_textbox.Text);
}
catch
{
message += ("Vous n'avez pas entré de noeud initial \r\n");
}
try
{
numfinal = Convert.ToInt32(noeud_fin_textbox.Text);
}
catch
{
message += ("Vous n'avez pas entré de noeud final \r\n");
}
if (message == "ERREUR \r\n")
{
g = new SearchTree();
N0 = new Node2();
N0.numero = numinitial;
L_Ouverts = new List <GenericNode>();
L_Fermes = new List <GenericNode>();
EnsembleOuvert = new List <List <GenericNode> >();
EnsembleFermes = new List <List <GenericNode> >();
N0List = new List <GenericNode>();
// Le noeud passé en paramètre est supposé être le noeud initial
GenericNode N = N0;
N0List.Add(N0);
L_Ouverts.Add(N0);
EnsembleOuvert.Add(N0List);
// 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_Fermes.Add(N);
L_Ouverts.Remove(N);
GenericNode solu = g.stepSolutionAEtoile(N, L_Ouverts, L_Fermes);
List <GenericNode> listOuvert = new List <GenericNode>(L_Ouverts);
EnsembleOuvert.Add(listOuvert);
List <GenericNode> listFermes = new List <GenericNode>(L_Fermes);
EnsembleFermes.Add(listFermes);
N = solu;
}
// renvois les noeuds parents jusqu'a avoir l'arbre total methode du SearchTree qui est passé en ligne de code directement.
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
}
}
solution = _LN;
g.PrintEmptyTree(treeViewEtudiant);
}
else
{
MessageBox.Show(message);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////// à partir de là nous pouvons commencer à comparer les ensembles. //////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////// fin des tests sur les ensembles ouverts et fermés ////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
/// affichage de l'arbre des solutions et du chemin le plus court à condition que l'étudiant ait entré des ensembles ouverts et fermés
}
public override int GetArcCost(GenericNode N2)
{
Node2 N2bis = (Node2)N2;
return(Dijkstra.matrice[numero, N2bis.numero]);
}
public void affichageSolution(Node2 N0, List <GenericNode> solution)
{
EnsembleOuvertEleve = new List <List <string> >();
EnsembleFermeEleve = new List <List <string> >();
Ouvert = new List <GenericNode>();
/////////////////////////////////////////////// Lecture des réponses de l'étudiant /////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////// Lecture des ensembles ouverts ///////////////
int lignes = 0;
List <string> LigneENsOuvElev = new List <string>();
while (lignes < ToutEnsembleOuvert.Lines.Length)
{
String ligne = ToutEnsembleOuvert.Lines[lignes];
int j = 0;
LigneENsOuvElev = new List <string>();
while (j < ToutEnsembleOuvert.Lines[lignes].Length)
{
if (ligne[j] != ',')
{
LigneENsOuvElev.Add(ligne[j].ToString());
j++;
}
else
{
j++;
}
}
EnsembleOuvertEleve.Add(LigneENsOuvElev);
lignes++;
}
////////////////// cas où l'eleve mets tous les ensembles fermés
int lignesF = 0;
List <string> LigneENsFerElev = new List <string>();
while (lignesF < ToutEnsembleFerme.Lines.Length)
{
String ligne = ToutEnsembleFerme.Lines[lignesF];
int j = 0;
LigneENsFerElev = new List <string>();
while (j < ToutEnsembleFerme.Lines[lignesF].Length)
{
if (ligne[j] != ',')
{
LigneENsFerElev.Add(ligne[j].ToString());
j++;
}
else
{
j++;
}
}
EnsembleFermeEleve.Add(LigneENsFerElev);
lignesF++;
}
Node2 N1 = N0;
if ((ToutEnsembleFerme.Lines.Length != 0) && (ToutEnsembleOuvert.Lines.Length != 0))
{
if (Convert.ToInt32(noeud_fin_textbox.Text) > nbnodes)
{
commentaireTextBox.Text += ("Le noeud final stipulé est plus grand que le nombre de noeuds total");
}
else
{
for (int i = 1; i < solution.Count; i++)
{
Node2 N2 = (Node2)solution[i];
affichageCheminListBox.Items.Add(Convert.ToString(N1.numero)
+ "--->" + Convert.ToString(N2.numero)
+ " : " + Convert.ToString(matrice[N1.numero, N2.numero]));
N1 = N2;
}
g.GetSearchTree(treeViewSolution);
}
}
ComparerTreeViews(treeViewSolution, treeViewEtudiant); // comparaison des treeView. Nous essayons de modifier la couleur de police au fur et à mesure
if (treeViewSolution.Nodes.Count == 0)
{
commentaireTextBox.Text += "Vous n'avez pas rempli l'arbre d'exploration\r\n";
}
else
{
ComparerTreeViews(treeViewSolution, treeViewEtudiant);
}
//////////////////////// Comparaison des Ensembles ouverts //////////////////////////
juste = true;
int CompteurO = 0;
while ((CompteurO < Math.Min(EnsembleOuvert.Count, EnsembleOuvertEleve.Count)) && (juste == true))
{
Ouvert = EnsembleOuvert.ElementAt(CompteurO);
List <string> LigneEnsOuv = EnsembleOuvertEleve.ElementAt(CompteurO);
if (Ouvert.Count == LigneEnsOuv.Count)
{
int i = 0;
while (i < Ouvert.Count && juste == true)
{
Node2 OuvertBis = (Node2)Ouvert[i];
int j = 0;
juste = false; // tant que la ligne ne contient pas de bonne réponse, on considere que c'est faut. On retourne donc faut si dans la ligne il n'y a pas la bonne réponse.
while (j < Ouvert.Count)
{
if (OuvertBis.getNumero() == LigneEnsOuv[j])
{
juste = true;
}
j++;
}
i++;
}
}
else
{
juste = false;
}
CompteurO++;
}
if (juste == true)
{
question1++;
commentaireTextBox.Text += ("Bravo, vous avez bien trouvé l'ensemble des ouverts \r\n");
}
else if (juste == false)
{
commentaireTextBox.Text += ("Vous vous etes trompé dans l'ensemble ouvert à l'étape :" + CompteurO + "\r\n");
}
// fin du test des ensembles ouverts dans l'ordre
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Test des ensembles fermés (toujours dans l'Ordre car si la personne les mets dans le désordre c'est qu'elle n'a pas compris le Dijkstra
juste = true;
int CompteurF = 0;
while ((CompteurF < Math.Min(L_Fermes.Count, EnsembleFermeEleve.Count)) && (juste == true))
{
Fermes = EnsembleFermes.ElementAt(CompteurF);
List <string> LigneEnsFer = EnsembleFermeEleve.ElementAt(CompteurF);
if (Fermes.Count == LigneEnsFer.Count)
{
int i = 0;
while (i < Fermes.Count && juste == true)
{
Node2 FermeBis = (Node2)Fermes[i];
int j = 0;
juste = false; // tant que la ligne ne contient pas de bonne réponse, on considere que c'est faut. On retourne donc faut si dans la ligne il n'y a pas la bonne réponse.
while (j < Fermes.Count)
{
if (FermeBis.getNumero() == LigneEnsFer[j])
{
juste = true;
}
j++;
}
i++;
}
}
else
{
juste = false;
}
CompteurF++;
}
if (juste == true)
{
question1++;
commentaireTextBox.Text += ("Bravo, vous avez bien trouvé l'ensemble des fermes \r\n");
}
else if (juste == false)
{
commentaireTextBox.Text += ("Vous vous etes trompé dans l'ensemble ferme à l'étape :" + CompteurF + "\r\n");
}
}
// 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);
}
