Comment implémenter un algorithme A *?
Quelle devrait être la façon d'obtenir une implémentation simple de l'algorithme A * (A star) en C #?
Cet article explique en détail l'implémentation de base:
Le but de ce billet de blog est de montrer les principes fondamentaux de A * à travers une implémentation C # très simple.
Il indique également de meilleures implémentations, plus adaptées à une utilisation en production:
En ce qui concerne les moyens de trouver de meilleurs itinéraires, il existe de nombreux exemples C # qui sont bien meilleurs et plus riches que celui-ci. CastorTi a une solution de démonstration vraiment agréable sur CodeProject, implémentation d'un algorithme A * en C # , qui anime l'algorithme de recherche et permet à l'utilisateur de modifier quelques paramètres. [...]
EpPathFinding.cs- Un algorithme de recherche de chemin rapide (Jump Point Search) en C # (basé sur la grille) . Il a une interface graphique claire et agréable et permet de modifier quelques paramètres.
Dans la fonction AStar, nous commençons par créer un nouveau matrixNode, avec les paramètres fromX et fromY. Un matrixNode a des propriétés, "fr" qui est la distance de tout matriceNode donnée du nœud de départ, une propriété "to" qui est la distance d'un matriceNode donné par rapport à la matrice matrixNode (serait 'E' aux coordonnées (3,3 ) dans l'exemple de unitTest), et une propriété "sum" qui est la somme de "to" et "fr". La propriété parent est une référence au matrixNode vers lequel le nœud donné a été déplacé dans le chemin d'accès du nœud de début au nœud de fin. Les dictionnaires verts et rouges sont respectivement openSet et closedSet comme décrit dans la page algorithme de recherche A * sur Wikipédia. L'idée générale avec ces ensembles, est que nous essayons de trouver le matrixNode dans l'ensemble vert/ouvert qui a la valeur de "somme" la plus faible, car "la somme" était la somme des distances du nœud par rapport au nœud de départ à ( fromX, fromY) et le nœud d'extrémité en (toX, toY)
public static void unitTest_AStar()
{
char[][] matrix = new char[][] { new char[] {'-', 'S', '-', '-', 'X'},
new char[] {'-', 'X', 'X', '-', '-'},
new char[] {'-', '-', '-', 'X', '-'},
new char[] {'X', '-', 'X', 'E', '-'},
new char[] {'-', '-', '-', '-', 'X'}};
//looking for shortest path from 'S' at (0,1) to 'E' at (3,3)
//obstacles marked by 'X'
int fromX = 0, fromY = 1, toX = 3, toY = 3;
matrixNode endNode = AStar(matrix, fromX, fromY, toX, toY);
//looping through the Parent nodes until we get to the start node
Stack<matrixNode> path = new Stack<matrixNode>();
while (endNode.x != fromX || endNode.y != fromY)
{
path.Push(endNode);
endNode = endNode.parent;
}
path.Push(endNode);
Console.WriteLine("The shortest path from " +
"(" + fromX + "," + fromY + ") to " +
"(" + toX + "," + toY + ") is: \n");
while (path.Count > 0)
{
matrixNode node = path.Pop();
Console.WriteLine("(" + node.x + "," + node.y + ")");
}
}
public class matrixNode
{
public int fr = 0, to = 0, sum = 0;
public int x, y;
public matrixNode parent;
}
public static matrixNode AStar(char[][] matrix, int fromX, int fromY, int toX, int toY)
{
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// in this version an element in a matrix can move left/up/right/down in one step, two steps for a diagonal move.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//the keys for greens and reds are x.ToString() + y.ToString() of the matrixNode
Dictionary<string, matrixNode> greens = new Dictionary<string, matrixNode>(); //open
Dictionary<string, matrixNode> reds = new Dictionary<string, matrixNode>(); //closed
matrixNode startNode = new matrixNode { x = fromX, y = fromY };
string key = startNode.x.ToString() + startNode.x.ToString();
greens.Add(key, startNode);
Func<KeyValuePair<string, matrixNode>> smallestGreen = () =>
{
KeyValuePair<string, matrixNode> smallest = greens.ElementAt(0);
foreach (KeyValuePair<string, matrixNode> item in greens)
{
if (item.Value.sum < smallest.Value.sum)
smallest = item;
else if (item.Value.sum == smallest.Value.sum
&& item.Value.to < smallest.Value.to)
smallest = item;
}
return smallest;
};
//add these values to current node's x and y values to get the left/up/right/bottom neighbors
List<KeyValuePair<int, int>> fourNeighbors = new List<KeyValuePair<int, int>>()
{ new KeyValuePair<int, int>(-1,0),
new KeyValuePair<int, int>(0,1),
new KeyValuePair<int, int>(1, 0),
new KeyValuePair<int, int>(0,-1) };
int maxX = matrix.GetLength(0);
if (maxX == 0)
return null;
int maxY = matrix[0].Length;
while (true)
{
if (greens.Count == 0)
return null;
KeyValuePair<string, matrixNode> current = smallestGreen();
if (current.Value.x == toX && current.Value.y == toY)
return current.Value;
greens.Remove(current.Key);
reds.Add(current.Key, current.Value);
foreach (KeyValuePair<int, int> plusXY in fourNeighbors)
{
int nbrX = current.Value.x + plusXY.Key;
int nbrY = current.Value.y + plusXY.Value;
string nbrKey = nbrX.ToString() + nbrY.ToString();
if (nbrX < 0 || nbrY < 0 || nbrX >= maxX || nbrY >= maxY
|| matrix[nbrX][nbrY] == 'X' //obstacles marked by 'X'
|| reds.ContainsKey(nbrKey))
continue;
if (greens.ContainsKey(nbrKey))
{
matrixNode curNbr = greens[nbrKey];
int from = Math.Abs(nbrX - fromX) + Math.Abs(nbrY - fromY);
if (from < curNbr.fr)
{
curNbr.fr = from;
curNbr.sum = curNbr.fr + curNbr.to;
curNbr.parent = current.Value;
}
}
else
{
matrixNode curNbr = new matrixNode { x = nbrX, y = nbrY };
curNbr.fr = Math.Abs(nbrX - fromX) + Math.Abs(nbrY - fromY);
curNbr.to = Math.Abs(nbrX - toX) + Math.Abs(nbrY - toY);
curNbr.sum = curNbr.fr + curNbr.to;
curNbr.parent = current.Value;
greens.Add(nbrKey, curNbr);
}
}
}
}