Esempio n. 1
0
 public abstract double GetArcCost(GenericNode N2);
Esempio n. 2
0
 public void SetNoeud_Parent(GenericNode g)
 {
     ParentNode = g;
     g.Enfants.Add(this);
 }
Esempio n. 3
0
 // Méthodes abstrates, donc à surcharger obligatoirement avec override dans une classe fille
 public abstract bool IsEqual(GenericNode N2);
Esempio n. 4
0
        protected List <GenericNode> Enfants; // noeuds enfants

        public GenericNode()
        {
            ParentNode = null;
            Enfants    = new List <GenericNode>();
        }
Esempio n. 5
0
        public override double GetArcCost(GenericNode N2)
        {
            Node2 N2bis = (Node2)N2;

            return(Form1.matrice[numero, N2bis.numero]);
        }
Esempio n. 6
0
        // 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);
        }
Esempio n. 7
0
        public List <GenericNode> RechercheSolutionAEtoile(GenericNode N0)
        {
            L_Ouverts = new List <GenericNode>();
            L_Fermes  = new List <GenericNode>();
            //Deux listes temporaires qui iront implementer Liste_Chaque_Etape
            List <GenericNode> fermTemp = new List <GenericNode>();
            List <GenericNode> ouvTemp  = new List <GenericNode>();

            // Le noeud passé en paramètre est supposé être le noeud initial
            GenericNode N = N0;

            L_Ouverts.Add(N0);
            ouvTemp.Add(N0);


            //Copie des noeuds dans les grosses listes d'ouverts et fermes
            liste_chaqueEtape_Fermes.Add(fermTemp);
            liste_chaqueEtape_Ouverts.Add(ouvTemp);


            // tant que le noeud n'est pas terminal et que ouverts n'est pas vide
            while (L_Ouverts.Count != 0 && N.EndState() == false)
            {
                //Deux listes temporaires qui iront implementer Liste_Chaque_Etape
                List <GenericNode> fermTemp2 = new List <GenericNode>();
                List <GenericNode> ouvTemp2  = new List <GenericNode>();

                // 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;
                }


                //implementation de ouvTemp et fermTemp

                foreach (GenericNode noeud in L_Fermes)
                {
                    fermTemp2.Add(noeud);
                }
                foreach (GenericNode noeud in L_Ouverts)
                {
                    ouvTemp2.Add(noeud);
                }

                //Copie des noeuds dans les grosses listes d'ouverts et fermes
                liste_chaqueEtape_Fermes.Add(fermTemp2);
                liste_chaqueEtape_Ouverts.Add(ouvTemp2);
            }
            // 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);
        }
Esempio n. 8
0
        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);
            ouverts += N.Name;


            // tant que le noeud n'est pas terminal et que ouverts n'est pas vide
            while (L_Ouverts.Count != 0 && N.EndState() == false)
            {
                //!!
                //L_L_Fermes.Add(L_Fermes);


                // 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);

                //ajout nouvelle liste de fermes : re ajoute les anciens fermés et ajoute le nouvea
                fermes += N.Name + ",";

                // 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];

                    ouverts += ",";
                    foreach (GenericNode G in L_Ouverts)
                    {
                        ouverts += G.Name;
                    }
                }
                else
                {
                    N = null;
                }
            }
            ouverts += ",";


            // 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);
        }