public virtual Solution <TMove> Solve(AGame <TMove> game, ANode <TMove> finalState)
{
this.graph = new Graph <TMove>(game.State);
this.game = game;
// Le noeud passé en paramètre est supposé être le noeud initial
var N = game.State;
this.graph.Opened.Add(N);
// tant que le noeud n'est pas terminal et que ouverts n'est pas vide
while (this.graph.Opened.Count != 0 && !finalState.Equals(N))
{
// Le meilleur noeud des ouverts est supposé placé en tête de liste
// On le place dans les fermés
this.graph.Opened.Remove(N);
this.graph.Closed.Add(N);
// Il faut trouver les noeuds successeurs de N
this.UpdateSuccessors(N, finalState);
// 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 (this.graph.Opened.Count > 0)
{
N = this.graph.Opened[0];
}
else
{
N = null;
}
}
this.graph.Finish(N);
return(Solution <TMove> .BuildPathFrom(this.graph));
}
public bool FindPath(ANode root, ANode dest)
{
PQueue queue = new PQueue();
if (!nodes.Contains(root))
{
nodes.Add(root);
foreach (APath x in root.GetPaths())
{
paths.Add(x);
}
}
if (!nodes.Contains(dest))
{
nodes.Add(dest);
foreach (APath x in dest.GetPaths())
{
paths.Add(x);
}
}
ANode currentNode = root;
currentNode.Cost = 0;
List <ANode> notVisited = new List <ANode>(nodes);
while (notVisited.Count > 0)
{
foreach (APath x in currentNode.GetPaths())
{
ANode neighbor = x.GetOtherSide(currentNode);
if (neighbor.Visited)
{
continue;
}
neighbor.UpdateHeuristic(GetHeuristicOf(neighbor, dest));
if (neighbor.Cost > currentNode.Cost + x.Cost)
{
neighbor.UpdateNodeCost(currentNode.Cost + x.Cost, currentNode);
}
queue.Enqueue(neighbor);
}
currentNode.Visited = true;
notVisited.Remove(currentNode);
if (notVisited.Count == 0)
{
break;
}
currentNode = queue.Dequeue();
if (currentNode.Equals(dest))
{
UpdatePath(root, dest);
return(true);
}
}
return(false);
}