Пример #1
0
        private void UpdateSuccessors(GenericNode node)
        {
            // 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> successors = node.GetSuccessors();

            foreach (GenericNode successorNode in successors)
            {
                // N2 est-il une copie d'un nœud déjà vu et placé dans la liste des fermés ?
                GenericNode closedSuccessor = SearchInClosed(successorNode);

                if (closedSuccessor == null)
                {
                    // Rien dans les fermés. Est-il dans les ouverts ?
                    GenericNode openedSuccessor = SearchInOpened(successorNode);

                    if (openedSuccessor != 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 (node.GCost + node.GetArcCost(successorNode) < openedSuccessor.GCost)
                        {
                            // Mise à jour de N2bis
                            // somme de GCost et HCost effectuée à la mise à jour de GCost
                            openedSuccessor.GCost = node.GCost + node.GetArcCost(successorNode);
                            // HCost pas recalculé car toujours bon
                            // Mise à jour de la famille ....
                            openedSuccessor.FlushParent();
                            openedSuccessor.ParentNode = node;
                            // Mise à jour des ouverts
                            OpenedNodes.Remove(openedSuccessor);
                            this.InsertNewNodeInOpenList(openedSuccessor);
                        }
                        // else on ne fait rien, car le nouveau chemin est moins bon
                    }
                    else
                    {
                        // N2 est nouveau, MAJ et insertion dans les ouverts
                        successorNode.GCost      = node.GCost + node.GetArcCost(successorNode);
                        successorNode.ParentNode = node;
                        this.InsertNewNodeInOpenList(successorNode);
                    }
                }
                // 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
            }
        }
Пример #2
0
        public void InsertNewNodeInOpenList(GenericNode NewNode)
        {
            // Insertion pour respecter l'ordre du cout total le plus petit au plus grand
            if (this.OpenedNodes.Count == 0)
            {
                OpenedNodes.Add(NewNode);
            }

            else
            {
                GenericNode genNode = OpenedNodes[0];
                bool        found   = false;
                int         i       = 0;
                do
                {
                    if (NewNode.TotCost < genNode.TotCost)
                    {
                        OpenedNodes.Insert(i, NewNode);
                        found = true;
                    }
                    else
                    {
                        i++;
                        if (OpenedNodes.Count == i)
                        {
                            genNode = null;
                            OpenedNodes.Insert(i, NewNode);
                        }
                        else
                        {
                            genNode = OpenedNodes[i];
                        }
                    }
                }while ((genNode != null) && (found == false));
            }
        }