logo

Un* algorithme de recherche en intelligence artificielle

Une introduction à l'algorithme de recherche A* dans l'IA

A* (prononcé « A-star ») est un puissant algorithme de traversée de graphiques et de recherche de chemin largement utilisé en intelligence artificielle et en informatique. Il est principalement utilisé pour trouver le chemin le plus court entre deux nœuds dans un graphique, compte tenu du coût estimé pour passer du nœud actuel au nœud de destination. Le principal avantage de l'algorithme est sa capacité à fournir un chemin optimal en explorant le graphique de manière plus informée par rapport aux algorithmes de recherche traditionnels tels que l'algorithme de Dijkstra.

L'algorithme A* combine les avantages de deux autres algorithmes de recherche : l'algorithme de Dijkstra et Greedy Best-First Search. Comme l'algorithme de Dijkstra, A* garantit que le chemin trouvé est aussi court que possible mais le fait plus efficacement en dirigeant sa recherche via une heuristique similaire à Greedy Best-First Search. Une fonction heuristique, notée h(n), estime le coût d’obtention d’un nœud n donné jusqu’au nœud de destination.

L'idée principale de A* est d'évaluer chaque nœud en fonction de deux paramètres :

la session est expirée
    g(n):le coût réel pour passer du nœud initial au nœud n. Il représente la somme des coûts des nœuds n bords sortants.h(n):Coût heuristique (également appelé « coût d'estimation ») du nœud n au nœud de destination n. Cette fonction heuristique spécifique au problème doit être acceptable, c’est-à-dire qu’elle ne surestime jamais le coût réel de la réalisation de l’objectif. La fonction d'évaluation du nœud n est définie comme f(n) = g(n) h(n).

L'algorithme A* sélectionne les nœuds à explorer en fonction de la valeur la plus basse de f(n), en préférant les nœuds dont le coût total estimé est le plus bas pour atteindre l'objectif. L'algorithme A* fonctionne :

  1. Créez une liste ouverte de nœuds trouvés mais non explorés.
  2. Créez une liste fermée pour contenir les nœuds déjà explorés.
  3. Ajouter un nœud de départ à la liste ouverte avec une valeur initiale de g
  4. Répétez les étapes suivantes jusqu'à ce que la liste ouverte soit vide ou que vous atteigniez le nœud cible :
    1. Recherchez le nœud avec la plus petite valeur f (c'est-à-dire le nœud avec le mineur g(n) h(n)) dans la liste ouverte.
    2. Déplacez le nœud sélectionné de la liste ouverte vers la liste fermée.
    3. Créez tous les descendants valides du nœud sélectionné.
    4. Pour chaque successeur, calculez sa valeur g comme la somme de la valeur g du nœud actuel et du coût de déplacement du nœud actuel vers le nœud successeur. Mettez à jour la valeur g du tracker lorsqu'un meilleur chemin est trouvé.
    5. Si le suiveur n'est pas dans la liste ouverte, ajoutez-le avec la valeur g calculée et calculez sa valeur h. S'il est déjà dans la liste ouverte, mettez à jour sa valeur g si le nouveau chemin est meilleur.
    6. Répétez le cycle. L'algorithme A* se termine lorsque le nœud cible est atteint ou lorsque la liste ouverte se vide, n'indiquant aucun chemin entre le nœud de départ et le nœud cible. L'algorithme de recherche A* est largement utilisé dans divers domaines tels que la robotique, les jeux vidéo, le routage réseau et les problèmes de conception car il est efficace et peut trouver des chemins optimaux dans des graphiques ou des réseaux.

Cependant, le choix d’une fonction heuristique adaptée et acceptable est essentiel pour que l’algorithme fonctionne correctement et fournisse une solution optimale.

Algorithmes de recherche informés

Histoire de l'algorithme de recherche A* en intelligence artificielle

Il a été développé par Peter Hart, Nils Nilsson et Bertram Raphael du Stanford Research Institute (maintenant SRI International) comme une extension de l'algorithme de Dijkstra et d'autres algorithmes de recherche de l'époque. A* a été publié pour la première fois en 1968 et a rapidement été reconnu pour son importance et son efficacité dans les communautés de l'intelligence artificielle et de l'informatique. Voici un bref aperçu des étapes les plus critiques de l’histoire de l’algorithme de recherche A* :

    Premiers algorithmes de recherche :Avant le développement de A*, divers algorithmes de recherche de graphes existaient, notamment la recherche en profondeur (DFS) et la recherche en largeur (BFS). Bien que ces algorithmes aient aidé à trouver des chemins, ils ne garantissaient pas l’optimalité ni ne considéraient des heuristiques pour guider la recherche.L'algorithme de Dijkstra :En 1959, l'informaticien néerlandais Edsger W. Dijkstra a introduit l'algorithme de Dijkstra, qui trouvait le chemin le plus court dans un graphe pondéré avec des poids de bord non négatifs. L'algorithme de Dijkstra était efficace, mais en raison de sa nature exhaustive, il présentait des limites lorsqu'il était utilisé sur des graphiques plus grands ouRecherche éclairée :Des algorithmes de recherche basés sur les connaissances (également appelés recherche heuristique) ont été développés pour incorporer des informations heuristiques, telles que les coûts estimés, afin de guider efficacement le processus de recherche. Greedy Best-First Search était l’un de ces algorithmes, mais il ne garantissait pas l’optimalité pour trouver le chemin le plus court.Développement A* :En 1968, Peter Hart, Nils Nilsson et Bertram Raphael ont introduit l'algorithme A* comme une combinaison de l'algorithme de Dijkstra et de Greedy Best-First Search. A* a utilisé une fonction heuristique pour estimer le coût du nœud actuel au nœud de destination en le combinant avec le coût réel pour atteindre le nœud actuel. Cela a permis à A* d’explorer le graphe plus consciemment, en évitant les chemins inutiles et en garantissant une solution optimale.Justice et perfection :Les auteurs de A* ont montré que l'algorithme est parfait (trouve toujours une solution si elle existe) et optimal (trouve le chemin le plus court) sous certaines conditions.Adoption généralisée et progrès :A* a rapidement gagné en popularité dans les communautés de l'IA et de l'informatique en raison de son efficacité. Les chercheurs et les développeurs ont étendu et appliqué l'algorithme A* à divers domaines, notamment la robotique, les jeux vidéo, l'ingénierie et le routage réseau. Plusieurs variantes et optimisations de l'algorithme A* ont été proposées au fil des ans, telles que Incremental A* et Parallel A*. Aujourd’hui, l’algorithme de recherche A* reste un algorithme fondamental et largement utilisé en intelligence artificielle et en traversée de graphes. Elle continue de jouer un rôle essentiel dans diverses applications et domaines de recherche. Son impact sur l’intelligence artificielle et sa contribution aux problèmes d’orientation et d’optimisation en ont fait un algorithme clé dans la recherche sur les systèmes intelligents.

Comment fonctionne l’algorithme de recherche A* en Intelligence Artificielle ?

L'algorithme de recherche A* (prononcé « lettre A ») est un algorithme de traversée de graphiques populaire et largement utilisé en intelligence artificielle et en informatique. Il est utilisé pour trouver le chemin le plus court entre un nœud de départ et un nœud de destination dans un graphe pondéré. A* est un algorithme de recherche informé qui utilise des heuristiques pour guider la recherche efficacement. L'algorithme de recherche A* fonctionne comme suit :

L'algorithme démarre par une file d'attente prioritaire pour stocker les nœuds à explorer. Il instancie également deux structures de données g(n) : le coût du chemin le plus court jusqu'à présent du nœud de départ au nœud n et h(n), le coût estimé (heuristique) du nœud n au nœud de destination. Il s’agit souvent d’une heuristique raisonnable, ce qui signifie qu’elle ne surestime jamais le coût réel de la réalisation d’un objectif. Placez le nœud initial dans la file d'attente prioritaire et définissez son g(n) sur 0. Si la file d'attente prioritaire n'est pas vide, supprimez le nœud avec le f(n) le plus bas de la file d'attente prioritaire. f(n) = g(n)h(n). Si le nœud supprimé est le nœud de destination, l'algorithme se termine et le chemin est trouvé. Sinon, développez le nœud et créez ses voisins. Pour chaque nœud voisin, calculez sa valeur g(n) initiale, qui est la somme de la valeur g du nœud actuel et du coût de déplacement du nœud actuel vers un nœud voisin. Si le nœud voisin n'est pas dans l'ordre de priorité ou si la valeur g(n) d'origine est inférieure à sa valeur g actuelle, mettez à jour sa valeur g et définissez son nœud parent sur le nœud actuel. Calculez la valeur f(n) du nœud voisin et ajoutez-la à la file d'attente prioritaire.

Si le cycle se termine sans trouver le nœud de destination, le graphique n'a aucun chemin du début à la fin. La clé de l’efficacité de A* réside dans son utilisation d’une fonction heuristique h(n) qui fournit une estimation du coût restant pour atteindre l’objectif de n’importe quel nœud. En combinant le coût réel g(n) avec le coût heuristique h(n), l’algorithme explore efficacement les chemins prometteurs, en priorisant les nœuds susceptibles de mener au chemin le plus court. Il est important de noter que l’efficacité de l’algorithme A* dépend fortement du choix de la fonction heuristique. Des heuristiques acceptables garantissent que l’algorithme trouve toujours le chemin le plus court, mais des heuristiques plus informées et plus précises peuvent conduire à une convergence plus rapide et à un espace de recherche réduit.

Avantages de l'algorithme de recherche A* en intelligence artificielle

L’algorithme de recherche A* offre plusieurs avantages en matière d’intelligence artificielle et de scénarios de résolution de problèmes :

    Solution optimale:A* garantit la recherche du chemin optimal (le plus court) du nœud de départ au nœud de destination dans le graphe pondéré étant donné une fonction heuristique acceptable. Cette optimalité est un avantage décisif dans de nombreuses applications où trouver le chemin le plus court est essentiel.Complétude :Si une solution existe, A* la trouvera, à condition que le graphe n'ait pas un coût infini. Cette propriété d'exhaustivité garantit que A* peut profiter d'une solution si elle existe.Efficacité:A* est efficace si une fonction heuristique efficace et acceptable est utilisée. Les heuristiques guident la recherche vers un objectif en se concentrant sur les chemins prometteurs et en évitant les explorations inutiles, rendant A* plus efficace que les algorithmes de recherche non conscients tels que la recherche en largeur ou la recherche en profondeur.Polyvalence:A* est largement applicable à divers domaines problématiques, notamment l'orientation, la planification d'itinéraires, la robotique, le développement de jeux, etc. A* peut être utilisé pour trouver efficacement des solutions optimales à condition qu’une heuristique significative puisse être définie.Recherche optimisée :A* maintient un ordre de priorité pour sélectionner les nœuds avec la valeur mineure f(n) (g(n) et h(n)) pour l'expansion. Cela lui permet d’explorer en premier les voies prometteuses, ce qui réduit l’espace de recherche et conduit à une convergence plus rapide.Efficacité de la mémoire :Contrairement à certains autres algorithmes de recherche, tels que la recherche en largeur, A* ne stocke qu'un nombre limité de nœuds dans la file d'attente prioritaire, ce qui le rend efficace en termes de mémoire, en particulier pour les grands graphes.Heuristique réglable :Les performances de A* peuvent être affinées en sélectionnant différentes fonctions heuristiques. Des heuristiques plus approfondies peuvent conduire à une convergence plus rapide et à des nœuds moins étendus.Des recherches approfondies :A* est un algorithme bien établi avec des décennies de recherche et d'applications pratiques. De nombreuses optimisations et variantes ont été développées, ce qui en fait un outil de dépannage fiable et bien compris.Recherche Internet:A* peut être utilisé pour la recherche de chemin sur le Web, où l'algorithme met constamment à jour le chemin en fonction des changements dans l'environnement ou de l'apparition de nouveaux chemins. Il permet une prise de décision en temps réel dans des scénarios dynamiques.

Inconvénients de l'algorithme de recherche A* en intelligence artificielle

Bien que l’algorithme de recherche A* (lettre A) soit une technique puissante et largement utilisée pour résoudre les problèmes de recherche de chemin et de parcours de graphes de l’IA, il présente des inconvénients et des limites. Voici quelques-uns des principaux inconvénients de l’algorithme de recherche :

    Précision heuristique :Les performances de l'algorithme A* dépendent fortement de la précision de la fonction heuristique utilisée pour estimer le coût du nœud actuel au nœud actuel. Si l'heuristique est inacceptable (ne surestime jamais le coût réel) ou incohérente (satisfait l'inégalité triangulaire), A* peut ne pas trouver un chemin optimal ou explorer plus de nœuds que nécessaire, affectant son efficacité et sa précision.Utilisation de la mémoire:A* nécessite que tous les nœuds visités soient conservés en mémoire pour garder une trace des chemins explorés. L'utilisation de la mémoire peut parfois devenir un problème important, en particulier lorsqu'il s'agit d'un espace de recherche important ou de ressources mémoire limitées.Complexité temporelle :Bien que A* soit généralement efficace, sa complexité temporelle peut être un problème pour de vastes espaces de recherche ou des graphiques. Dans le pire des cas, A* peut prendre exponentiellement plus de temps pour trouver le chemin optimal si l'heuristique est inappropriée pour le problème.Goulet d'étranglement à destination :Dans des scénarios spécifiques, l'algorithme A* doit explorer les nœuds éloignés de la destination avant d'atteindre finalement la région de destination. Ce problème se produit lorsque l’heuristique doit diriger la recherche vers l’objectif de manière efficace et précoce.Liaison des coûts :A* rencontre des difficultés lorsque plusieurs nœuds ont la même valeur f (la somme du coût réel et du coût heuristique). La stratégie utilisée peut affecter l’optimalité et l’efficacité du chemin découvert. S'il n'est pas géré correctement, cela peut conduire à l'exploration de nœuds inutiles et ralentir l'algorithme.Complexité dans des environnements dynamiques :Dans des environnements dynamiques où le coût des arêtes ou des nœuds peut changer au cours de la recherche, A* peut ne pas convenir car il ne s'adapte pas bien à de tels changements. La reformulation à partir de zéro peut être coûteuse en termes de calcul, et les algorithmes D* (Dynamic A*) ont été conçus pour résoudre ce problème.La perfection dans l'espace infini :A* peut ne pas trouver de solution dans un espace d’états infini. Dans de tels cas, il peut fonctionner indéfiniment, explorant un nombre toujours croissant de nœuds sans trouver de solution. Malgré ces défauts, A* reste un algorithme robuste et largement utilisé car il peut trouver efficacement des chemins optimaux dans de nombreuses situations pratiques si la fonction heuristique est bien conçue et si l’espace de recherche est gérable. Diverses variations et variantes de A* ont été proposées pour atténuer certaines de ses limitations.

Applications de l'algorithme de recherche A* en intelligence artificielle

L'algorithme de recherche A* (lettre A) est un algorithme de recherche de chemin largement utilisé et robuste en intelligence artificielle et en informatique. Son efficacité et son optimalité le rendent adapté à diverses applications. Voici quelques applications typiques de l’algorithme de recherche A* en intelligence artificielle :

    Orientation dans les jeux :A* est souvent utilisé dans les jeux vidéo pour le déplacement des personnages, la navigation de l'IA ennemie et la recherche du chemin le plus court d'un endroit à un autre sur la carte du jeu. Sa capacité à trouver le chemin optimal en fonction du coût et des heuristiques le rend idéal pour les applications en temps réel telles que les jeux.Robotique et véhicules autonomes :A* est utilisé en robotique et dans la navigation des véhicules autonomes pour planifier un itinéraire optimal permettant aux robots d'atteindre une destination, en évitant les obstacles et en tenant compte des coûts de terrain. Ceci est crucial pour une circulation efficace et sûre dans les environnements naturels.Résolution de labyrinthe :A* peut trouver efficacement le chemin le plus court à travers un labyrinthe, ce qui le rend précieux dans de nombreuses applications de résolution de labyrinthes, telles que la résolution d'énigmes ou la navigation dans des structures complexes.Planification d'itinéraire et navigation :Dans les systèmes GPS et les applications de cartographie, A* peut être utilisé pour trouver l'itinéraire optimal entre deux points sur une carte, en tenant compte de facteurs tels que la distance, les conditions de circulation et la topologie du réseau routier.Résolution d'énigmes :A* peut résoudre diverses énigmes de diagramme, telles que les énigmes coulissantes, le Sudoku et le problème des 8 énigmes. Allocation des ressources : dans les scénarios où les ressources doivent être allouées de manière optimale, A* peut aider à trouver la voie d'allocation la plus efficace, en minimisant les coûts et en maximisant l'efficacité.Routage réseau :A* peut être utilisé dans les réseaux informatiques pour trouver l'itinéraire le plus efficace pour les paquets de données d'une source à un nœud de destination.Traitement du langage naturel (NLP) :Dans certaines tâches de PNL, A* peut générer des réponses cohérentes et contextuelles en recherchant des séquences de mots possibles en fonction de leur probabilité et de leur pertinence.Planification de parcours en robotique :A* peut être utilisé pour planifier le trajet d'un robot d'un point à un autre, en tenant compte de diverses contraintes, comme éviter les obstacles ou minimiser la consommation d'énergie.Game AI:A* est également utilisé pour prendre des décisions intelligentes pour les personnages non-joueurs (PNJ), comme déterminer la meilleure façon d'atteindre un objectif ou de coordonner des mouvements dans un jeu en équipe.

Ce ne sont là que quelques exemples de la manière dont l’algorithme de recherche A* trouve des applications dans divers domaines de l’intelligence artificielle. Sa flexibilité, son efficacité et son optimisation en font un outil précieux pour de nombreux problèmes.

décodage javascript base64

Programme C pour l'algorithme de recherche A* en intelligence artificielle

 #include #include #define ROWS 5 #define COLS 5 // Define a structure for a grid cell typedef struct { int row, col; } Cell; // Define a structure for a node in the A* algorithm typedef struct { Cell position; int g, h, f; struct Node* parent; } Node; // Function to calculate the Manhattan distance between two cells int heuristic(Cell current, Cell goal) { return abs(current.row - goal.row) + abs(current.col - goal.col); } // Function to check if a cell is valid (within the grid and not an obstacle) int isValid(int row, int col, int grid[ROWS][COLS]) { return (row &gt;= 0) &amp;&amp; (row = 0) &amp;&amp; (col <cols) && (grid[row][col]="=" 0); } function to check if a cell is the goal int isgoal(cell cell, goal) { return (cell.row="=" goal.row) (cell.col="=" goal.col); perform a* search algorithm void astarsearch(int grid[rows][cols], start, todo: implement here main() grid[rows][cols]="{" {0, 1, 0, 0}, 0} }; start="{0," 0}; - cols 1}; astarsearch (grid, goal); 0; < pre> <p> <strong>Explanation:</strong> </p> <ol class="points"> <tr><td>Data Structures:</td> A cell structure represents a grid cell with a row and a column. The node structure stores information about a cell during an A* lookup, including its location, cost (g, h, f), and a reference to its parent. </tr><tr><td>Heuristic function (heuristic):</td> This function calculates the Manhattan distance (also known as a &apos;cab ride&apos;) between two cells. It is used as a heuristic to estimate the cost from the current cell to the target cell. The Manhattan distance is the sum of the absolute differences between rows and columns. </tr><tr><td>Validation function (isValid):</td> This function checks if the given cell is valid, i.e., whether it is within the grid boundaries and is not an obstacle (indicated by a grid value of 1). </tr><tr><td>Goal check function (isGoal):</td> This function checks if the given cell is a target cell, i.e., does it match the coordinates of the target cell. </tr><tr><td>Search function* (AStarSearch):</td> This is the main function where the A* search algorithm should be applied. It takes a grid, a source cell, and a target cell as inputs. This activity aims to find the shortest path from the beginning to the end, avoiding the obstacles on the grid. The main function initializes a grid representing the environment, a start, and a target cell. It then calls the AStarSearch function with those inputs. </tr></ol> <p> <strong>Sample Output</strong> </p> <pre> (0, 0) (1, 0) (2, 0) (3, 0) (4, 0) (4, 1) (4, 2) (4, 3) (4, 4) </pre> <h3>C++ program for A* Search Algorithm in Artificial Intelligence</h3> <pre> #include #include #include using namespace std; struct Node { int x, y; // Coordinates of the node int g; // Cost from the start node to this node int h; // Heuristic value (estimated cost from this node to the goal node) Node* parent; // Parent node in the path Node (int x, int y): x(x), y(y), g(0), h(0), parent(nullptr) {} // Calculate the total cost (f = g + h) int f () const { return g + h; } }; // Heuristic function (Euclidean distance) int calculateHeuristic (int x, int y, int goals, int goal) { return static cast (sqrt (pow (goals - x, 2) + pow (goal - y, 2))); } // A* search algorithm vector<pair> AStarSearch (int startX, int startY, int goals, int goal, vector<vector>&amp; grid) { vector<pair> path; int rows = grid. size (); int cols = grid [0].size (); // Create the open and closed lists Priority queue <node*, vector, function> open List([](Node* lhs, Node* rhs) { return lhs-&gt;f() &gt; rhs-&gt;f(); }); vector<vector> closed List (rows, vector (cols, false)); // Push the start node to the open list openList.push(start Node); // Main A* search loop while (! Open-list. Empty ()) { // Get the node with the lowest f value from the open list Node* current = open-list. Top (); openest. pop (); // Check if the current node is the goal node if (current-&gt;x == goals &amp;&amp; current-&gt;y == goal) { // Reconstruct the path while (current! = nullptr) { path. push_back(make_pair(current-&gt;x, current-&gt;y)); current = current-&gt;parent; } Reverse (path. Begin(), path.end ()); break; } // Mark the current node as visited (in the closed list) Closed-list [current-&gt;x] [current-&gt;y] = true; // Generate successors (adjacent nodes) int dx [] = {1, 0, -1, 0}; int dy [] = {0, 1, 0, -1}; for (int i = 0; i x + dx [i]; int new Y = current-&gt;y + dy [i]; } break; } successor-&gt;parent = current; open List.push(successor); } // Cleanup memory for (Node* node: open List) { delete node; } return path; } int main () { int rows, cols; cout &lt;&gt; rows; cout &lt;&gt; cols; vector<vector> grid (rows, vector(cols)); cout &lt;&lt; &apos;Enter the grid (0 for empty, 1 for obstacle):&apos; &lt;&lt; endl; for (int i = 0; i &lt; rows; i++) { for (int j = 0; j&gt; grid[i][j]; } } int startX, startY, goalX, goalY; cout &lt;&gt; startX &gt;&gt; start; cout &lt;&gt; goals &gt;&gt; goals; vector<pair> path = AStarSearch (startX, startY, goal, goal, grid); if (! path. Empty ()) { cout &lt;&lt; &apos;Shortest path from (&apos; &lt;&lt; startX &lt;&lt; &apos;,&apos; &lt;&lt; start &lt;&lt; &apos;) to (&apos; &lt;&lt; goal &lt;&lt; &apos;,&apos; &lt;&lt; goal &lt;&lt; &apos;):&apos; &lt;&lt; endl; for (const auto&amp; point: path) { cout &lt;&lt; &apos;(&apos; &lt;&lt; point. first &lt;&lt; &apos;,&apos; &lt;&lt; point. second &lt;&lt; &apos;) &apos;; } cout &lt;&lt; endl; } else { cout &lt;&lt; &apos;No path found!&apos; &lt;&lt; endl; } return 0; } </pair></vector></vector></node*,></pair></vector></pair></pre> <p> <strong>Explanation:</strong> </p> <ol class="points"> <tr><td>Struct Node:</td> This defines a nodestructure that represents a grid cell. It contains the x and y coordinates of the node, the cost g from the starting node to that node, the heuristic value h (estimated cost from that node to the destination node), and a pointer to the <li>starting node of the path.</li> </tr><tr><td>Calculate heuristic:</td> This function calculates a heuristic using the Euclidean distance between a node and the target AStarSearch: This function runs the A* search algorithm. It takes the start and destination coordinates, a grid, and returns a vector of pairs representing the coordinates of the shortest path from start to finish. </tr><tr><td>Primary:</td> The program&apos;s main function takes input grids, origin, and target coordinates from the user. It then calls AStarSearch to find the shortest path and prints the result. Struct Node: This defines a node structure that represents a grid cell. It contains the x and y coordinates of the node, the cost g from the starting node to that node, the heuristic value h (estimated cost from that node to the destination node), and a pointer to the starting node of the path. </tr><tr><td>Calculate heuristic:</td> This function calculates heuristics using the Euclidean distance between a node and the target AStarSearch: This function runs the A* search algorithm. It takes the start and destination coordinates, a grid, and returns a vector of pairs representing the coordinates of the shortest path from start to finish. </tr></ol> <p> <strong>Sample Output</strong> </p> <pre> Enter the number of rows: 5 Enter the number of columns: 5 Enter the grid (0 for empty, 1 for obstacle): 0 0 0 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 Enter the start coordinates (x y): 0 0 Enter the goal coordinates (x y): 4 4 </pre> <h3>Java program for A* Search Algorithm in Artificial Intelligence</h3> <pre> import java. util.*; class Node { int x, y; // Coordinates of the node int g; // Cost from the start node to the current node int h; // Heuristic value (estimated cost from the current node to goal node) int f; // Total cost f = g + h Node parent; // Parent node in the path public Node (int x, int y) { this. g = x; this. f = y; this. Parent = null; } } public class AStarSearch { // Heuristic function (Manhattan distance) private static int heuristic (Node current, Node goal) { return Math. Abs (current.x - goal.x) + Math. Abs(current.y - goal.y); } // A* search algorithm public static List aStarSearch(int [][] grid, Node start, Node goal) { int rows = grid. Length; int cols = grid [0].length; // Add the start node to the open set opened.add(start); while (! openSet.isEmpty()) { // Get the node with the lowest f value from the open set Node current = openSet.poll(); // If the current node is the goal node, reconstruct the path and return it if (current == goal) { List path = new ArrayList(); while (current != null) { path.add(0, current); current = current.parent; } return path; } // Move the current node from the open set to the closed set closedSet.add(current); // Generate neighbors of the current node int[] dx = {-1, 0, 1, 0}; int[] dy = {0, -1, 0, 1}; for (int i = 0; i = 0 &amp;&amp; nx = 0 &amp;&amp; ny = neighbor.g) { // Skip this neighbor as it is already in the closed set with a lower or equal g value continue; } if (!openSet.contains(neighbor) || tentativeG <neighbor.g) { update the neighbor's values neighbor.g="tentativeG;" neighbor.h="heuristic(neighbor," goal); neighbor.f="neighbor.g" + neighbor.h; neighbor.parent="current;" if (!openset.contains(neighbor)) add neighbor to open set not already present openset.add(neighbor); } is empty and goal reached, there no path return null; public static void main(string[] args) int[][] grid="{" {0, 0, 0}, 1, 0} }; node start="new" node(0, 0); node(4, 4); list start, (path !="null)" system.out.println('path found:'); for (node : path) system.out.println('(' node.x ', ' node.y ')'); else system.out.println('no found.'); < pre> <p> <strong>Explanation:</strong> </p> <ol class="points"> <tr><td>Node Class:</td> We start by defining a nodeclass representing each grid cell. Each node contains coordinates (x, y), an initial node cost (g), a heuristic value (h), a total cost (f = g h), and a reference to the parent node of the path. </tr><tr><td>Heuristicfunction:</td> The heuristic function calculates the Manhattan distance between a node and a destination The Manhattan distance is a heuristic used to estimate the cost from the current node to the destination node. </tr><tr><td>Search algorithm* function:</td> A Star Search is the primary implementation of the search algorithm A*. It takes a 2D grid, a start node, and a destination node as inputs and returns a list of nodes representing the path from the start to the destination node. </tr><tr><td>Priority Queue and Closed Set:</td> The algorithm uses a priority queue (open Set) to track thenodes to be explored. The queue is ordered by total cost f, so the node with the lowest f value is examined The algorithm also uses a set (closed set) to track the explored nodes. </tr><tr><td>The main loop of the algorithm:</td> The main loop of the A* algorithm repeats until there are no more nodes to explore in the open Set. In each iteration, the node f with the lowest total cost is removed from the opener, and its neighbors are created. </tr><tr><td>Creating neighbors:</td> The algorithm creates four neighbors (up, down, left, right) for each node and verifies that each neighbor is valid (within the network boundaries and not as an obstacle). If the neighbor is valid, it calculates the initial value g from the source node to that neighbor and the heuristic value h from that neighbor to the destination The total cost is then calculated as the sum of f, g, and h. </tr><tr><td>Node evaluation:</td> The algorithm checks whether the neighbor is already in the closed set and, if so, whether the initial cost g is greater than or equal to the existing cost of the neighbor If true, the neighbor is omitted. Otherwise, the neighbor values are updated and added to the open Set if it is not already there. </tr><tr><td>Pathreconstruction:</td> When the destination node is reached, the algorithm reconstructs the path from the start node to the destination node following the main links from the destination node back to the start node. The path is returned as a list of nodes </tr></ol> <p> <strong>Sample Output</strong> </p> <pre> Path found: (0, 0) (0, 1) (1, 1) (2, 1) (2, 2) (3, 2) (4, 2) (4, 3) (4, 4) </pre> <h2>A* Search Algorithm Complexity in Artificial Intelligence</h2> <p>The A* (pronounced &apos;A-star&apos;) search algorithm is a popular and widely used graph traversal and path search algorithm in artificial intelligence. Finding the shortest path between two nodes in a graph or grid-based environment is usually common. The algorithm combines Dijkstra&apos;s and greedy best-first search elements to explore the search space while ensuring optimality efficiently. Several factors determine the complexity of the A* search algorithm. Graph size (nodes and edges): A graph&apos;s number of nodes and edges greatly affects the algorithm&apos;s complexity. More nodes and edges mean more possible options to explore, which can increase the execution time of the algorithm.</p> <p>Heuristic function: A* uses a heuristic function (often denoted h(n)) to estimate the cost from the current node to the destination node. The precision of this heuristic greatly affects the efficiency of the A* search. A good heuristic can help guide the search to a goal more quickly, while a bad heuristic can lead to unnecessary searching.</p> <ol class="points"> <tr><td>Data Structures:</td> A* maintains two maindata structures: an open list (priority queue) and a closed list (or visited pool). The efficiency of these data structures, along with the chosen implementation (e.g., priority queue binary heaps), affects the algorithm&apos;s performance. </tr><tr><td>Branch factor:</td> The average number of followers for each node affects the number of nodes expanded during the search. A higher branching factor can lead to more exploration, which increases </tr><tr><td>Optimality and completeness:</td> A* guarantees both optimality (finding the shortest path) and completeness (finding a solution that exists). However, this guarantee comes with a trade-off in terms of computational complexity, as the algorithm must explore different paths for optimal performance. Regarding time complexity, the chosen heuristic function affects A* in the worst case. With an accepted heuristic (which never overestimates the true cost of reaching the goal), A* expands the fewest nodes among the optimization algorithms. The worst-case time complexity of A * is exponential in the worst-case O(b ^ d), where &apos;b&apos; is the effective branching factor (average number of followers per node) and &apos;d&apos; is the optimal </tr></ol> <p>In practice, however, A* often performs significantly better due to the influence of a heuristic function that helps guide the algorithm to promising paths. In the case of a well-designed heuristic, the effective branching factor is much smaller, which leads to a faster approach to the optimal solution.</p> <hr></neighbor.g)></pre></cols)>

Programme C++ pour l'algorithme de recherche A* en intelligence artificielle

 #include #include #include using namespace std; struct Node { int x, y; // Coordinates of the node int g; // Cost from the start node to this node int h; // Heuristic value (estimated cost from this node to the goal node) Node* parent; // Parent node in the path Node (int x, int y): x(x), y(y), g(0), h(0), parent(nullptr) {} // Calculate the total cost (f = g + h) int f () const { return g + h; } }; // Heuristic function (Euclidean distance) int calculateHeuristic (int x, int y, int goals, int goal) { return static cast (sqrt (pow (goals - x, 2) + pow (goal - y, 2))); } // A* search algorithm vector<pair> AStarSearch (int startX, int startY, int goals, int goal, vector<vector>&amp; grid) { vector<pair> path; int rows = grid. size (); int cols = grid [0].size (); // Create the open and closed lists Priority queue <node*, vector, function> open List([](Node* lhs, Node* rhs) { return lhs-&gt;f() &gt; rhs-&gt;f(); }); vector<vector> closed List (rows, vector (cols, false)); // Push the start node to the open list openList.push(start Node); // Main A* search loop while (! Open-list. Empty ()) { // Get the node with the lowest f value from the open list Node* current = open-list. Top (); openest. pop (); // Check if the current node is the goal node if (current-&gt;x == goals &amp;&amp; current-&gt;y == goal) { // Reconstruct the path while (current! = nullptr) { path. push_back(make_pair(current-&gt;x, current-&gt;y)); current = current-&gt;parent; } Reverse (path. Begin(), path.end ()); break; } // Mark the current node as visited (in the closed list) Closed-list [current-&gt;x] [current-&gt;y] = true; // Generate successors (adjacent nodes) int dx [] = {1, 0, -1, 0}; int dy [] = {0, 1, 0, -1}; for (int i = 0; i x + dx [i]; int new Y = current-&gt;y + dy [i]; } break; } successor-&gt;parent = current; open List.push(successor); } // Cleanup memory for (Node* node: open List) { delete node; } return path; } int main () { int rows, cols; cout &lt;&gt; rows; cout &lt;&gt; cols; vector<vector> grid (rows, vector(cols)); cout &lt;&lt; &apos;Enter the grid (0 for empty, 1 for obstacle):&apos; &lt;&lt; endl; for (int i = 0; i &lt; rows; i++) { for (int j = 0; j&gt; grid[i][j]; } } int startX, startY, goalX, goalY; cout &lt;&gt; startX &gt;&gt; start; cout &lt;&gt; goals &gt;&gt; goals; vector<pair> path = AStarSearch (startX, startY, goal, goal, grid); if (! path. Empty ()) { cout &lt;&lt; &apos;Shortest path from (&apos; &lt;&lt; startX &lt;&lt; &apos;,&apos; &lt;&lt; start &lt;&lt; &apos;) to (&apos; &lt;&lt; goal &lt;&lt; &apos;,&apos; &lt;&lt; goal &lt;&lt; &apos;):&apos; &lt;&lt; endl; for (const auto&amp; point: path) { cout &lt;&lt; &apos;(&apos; &lt;&lt; point. first &lt;&lt; &apos;,&apos; &lt;&lt; point. second &lt;&lt; &apos;) &apos;; } cout &lt;&lt; endl; } else { cout &lt;&lt; &apos;No path found!&apos; &lt;&lt; endl; } return 0; } </pair></vector></vector></node*,></pair></vector></pair>

Explication:

    Nœud de structure :Ceci définit une structure de nœuds qui représente une cellule de grille. Il contient les coordonnées x et y du nœud, le coût g du nœud de départ à ce nœud, la valeur heuristique h (coût estimé de ce nœud au nœud de destination) et un pointeur vers le nœud de destination.
  1. nœud de départ du chemin.
  2. Calculer l'heuristique :Cette fonction calcule une heuristique en utilisant la distance euclidienne entre un nœud et la cible AStarSearch : Cette fonction exécute l'algorithme de recherche A*. Il prend les coordonnées de départ et de destination, une grille et renvoie un vecteur de paires représentant les coordonnées du chemin le plus court du début à la fin.Primaire:La fonction principale du programme prend les grilles d'entrée, l'origine et les coordonnées cibles de l'utilisateur. Il appelle ensuite AStarSearch pour trouver le chemin le plus court et imprime le résultat. Struct Node : Ceci définit une structure de nœud qui représente une cellule de grille. Il contient les coordonnées x et y du nœud, le coût g du nœud de départ à ce nœud, la valeur heuristique h (coût estimé de ce nœud au nœud de destination) et un pointeur vers le nœud de départ du chemin.Calculer l'heuristique :Cette fonction calcule l'heuristique en utilisant la distance euclidienne entre un nœud et la cible AStarSearch : Cette fonction exécute l'algorithme de recherche A*. Il prend les coordonnées de départ et de destination, une grille et renvoie un vecteur de paires représentant les coordonnées du chemin le plus court du début à la fin.

Exemple de sortie

 Enter the number of rows: 5 Enter the number of columns: 5 Enter the grid (0 for empty, 1 for obstacle): 0 0 0 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 Enter the start coordinates (x y): 0 0 Enter the goal coordinates (x y): 4 4 

Programme Java pour l'algorithme de recherche A* en intelligence artificielle

 import java. util.*; class Node { int x, y; // Coordinates of the node int g; // Cost from the start node to the current node int h; // Heuristic value (estimated cost from the current node to goal node) int f; // Total cost f = g + h Node parent; // Parent node in the path public Node (int x, int y) { this. g = x; this. f = y; this. Parent = null; } } public class AStarSearch { // Heuristic function (Manhattan distance) private static int heuristic (Node current, Node goal) { return Math. Abs (current.x - goal.x) + Math. Abs(current.y - goal.y); } // A* search algorithm public static List aStarSearch(int [][] grid, Node start, Node goal) { int rows = grid. Length; int cols = grid [0].length; // Add the start node to the open set opened.add(start); while (! openSet.isEmpty()) { // Get the node with the lowest f value from the open set Node current = openSet.poll(); // If the current node is the goal node, reconstruct the path and return it if (current == goal) { List path = new ArrayList(); while (current != null) { path.add(0, current); current = current.parent; } return path; } // Move the current node from the open set to the closed set closedSet.add(current); // Generate neighbors of the current node int[] dx = {-1, 0, 1, 0}; int[] dy = {0, -1, 0, 1}; for (int i = 0; i = 0 &amp;&amp; nx = 0 &amp;&amp; ny = neighbor.g) { // Skip this neighbor as it is already in the closed set with a lower or equal g value continue; } if (!openSet.contains(neighbor) || tentativeG <neighbor.g) { update the neighbor\'s values neighbor.g="tentativeG;" neighbor.h="heuristic(neighbor," goal); neighbor.f="neighbor.g" + neighbor.h; neighbor.parent="current;" if (!openset.contains(neighbor)) add neighbor to open set not already present openset.add(neighbor); } is empty and goal reached, there no path return null; public static void main(string[] args) int[][] grid="{" {0, 0, 0}, 1, 0} }; node start="new" node(0, 0); node(4, 4); list start, (path !="null)" system.out.println(\'path found:\'); for (node : path) system.out.println(\'(\' node.x \', \' node.y \')\'); else system.out.println(\'no found.\'); < pre> <p> <strong>Explanation:</strong> </p> <ol class="points"> <tr><td>Node Class:</td> We start by defining a nodeclass representing each grid cell. Each node contains coordinates (x, y), an initial node cost (g), a heuristic value (h), a total cost (f = g h), and a reference to the parent node of the path. </tr><tr><td>Heuristicfunction:</td> The heuristic function calculates the Manhattan distance between a node and a destination The Manhattan distance is a heuristic used to estimate the cost from the current node to the destination node. </tr><tr><td>Search algorithm* function:</td> A Star Search is the primary implementation of the search algorithm A*. It takes a 2D grid, a start node, and a destination node as inputs and returns a list of nodes representing the path from the start to the destination node. </tr><tr><td>Priority Queue and Closed Set:</td> The algorithm uses a priority queue (open Set) to track thenodes to be explored. The queue is ordered by total cost f, so the node with the lowest f value is examined The algorithm also uses a set (closed set) to track the explored nodes. </tr><tr><td>The main loop of the algorithm:</td> The main loop of the A* algorithm repeats until there are no more nodes to explore in the open Set. In each iteration, the node f with the lowest total cost is removed from the opener, and its neighbors are created. </tr><tr><td>Creating neighbors:</td> The algorithm creates four neighbors (up, down, left, right) for each node and verifies that each neighbor is valid (within the network boundaries and not as an obstacle). If the neighbor is valid, it calculates the initial value g from the source node to that neighbor and the heuristic value h from that neighbor to the destination The total cost is then calculated as the sum of f, g, and h. </tr><tr><td>Node evaluation:</td> The algorithm checks whether the neighbor is already in the closed set and, if so, whether the initial cost g is greater than or equal to the existing cost of the neighbor If true, the neighbor is omitted. Otherwise, the neighbor values are updated and added to the open Set if it is not already there. </tr><tr><td>Pathreconstruction:</td> When the destination node is reached, the algorithm reconstructs the path from the start node to the destination node following the main links from the destination node back to the start node. The path is returned as a list of nodes </tr></ol> <p> <strong>Sample Output</strong> </p> <pre> Path found: (0, 0) (0, 1) (1, 1) (2, 1) (2, 2) (3, 2) (4, 2) (4, 3) (4, 4) </pre> <h2>A* Search Algorithm Complexity in Artificial Intelligence</h2> <p>The A* (pronounced &apos;A-star&apos;) search algorithm is a popular and widely used graph traversal and path search algorithm in artificial intelligence. Finding the shortest path between two nodes in a graph or grid-based environment is usually common. The algorithm combines Dijkstra&apos;s and greedy best-first search elements to explore the search space while ensuring optimality efficiently. Several factors determine the complexity of the A* search algorithm. Graph size (nodes and edges): A graph&apos;s number of nodes and edges greatly affects the algorithm&apos;s complexity. More nodes and edges mean more possible options to explore, which can increase the execution time of the algorithm.</p> <p>Heuristic function: A* uses a heuristic function (often denoted h(n)) to estimate the cost from the current node to the destination node. The precision of this heuristic greatly affects the efficiency of the A* search. A good heuristic can help guide the search to a goal more quickly, while a bad heuristic can lead to unnecessary searching.</p> <ol class="points"> <tr><td>Data Structures:</td> A* maintains two maindata structures: an open list (priority queue) and a closed list (or visited pool). The efficiency of these data structures, along with the chosen implementation (e.g., priority queue binary heaps), affects the algorithm&apos;s performance. </tr><tr><td>Branch factor:</td> The average number of followers for each node affects the number of nodes expanded during the search. A higher branching factor can lead to more exploration, which increases </tr><tr><td>Optimality and completeness:</td> A* guarantees both optimality (finding the shortest path) and completeness (finding a solution that exists). However, this guarantee comes with a trade-off in terms of computational complexity, as the algorithm must explore different paths for optimal performance. Regarding time complexity, the chosen heuristic function affects A* in the worst case. With an accepted heuristic (which never overestimates the true cost of reaching the goal), A* expands the fewest nodes among the optimization algorithms. The worst-case time complexity of A * is exponential in the worst-case O(b ^ d), where &apos;b&apos; is the effective branching factor (average number of followers per node) and &apos;d&apos; is the optimal </tr></ol> <p>In practice, however, A* often performs significantly better due to the influence of a heuristic function that helps guide the algorithm to promising paths. In the case of a well-designed heuristic, the effective branching factor is much smaller, which leads to a faster approach to the optimal solution.</p> <hr></neighbor.g)>

A* Complexité des algorithmes de recherche en intelligence artificielle

L'algorithme de recherche A* (prononcé « A-star ») est un algorithme de recherche de parcours et de chemin de graphe populaire et largement utilisé en intelligence artificielle. Trouver le chemin le plus court entre deux nœuds dans un environnement graphique ou basé sur une grille est généralement courant. L'algorithme combine les éléments de recherche de Dijkstra et les éléments de recherche gourmands en premier pour explorer l'espace de recherche tout en garantissant efficacement l'optimalité. Plusieurs facteurs déterminent la complexité de l’algorithme de recherche A*. Taille du graphique (nœuds et arêtes) : le nombre de nœuds et d'arêtes d'un graphique affecte grandement la complexité de l'algorithme. Plus de nœuds et d’arêtes signifient plus d’options possibles à explorer, ce qui peut augmenter le temps d’exécution de l’algorithme.

Fonction heuristique : A* utilise une fonction heuristique (souvent notée h(n)) pour estimer le coût du nœud actuel au nœud de destination. La précision de cette heuristique affecte grandement l’efficacité de la recherche A*. Une bonne heuristique peut aider à guider la recherche vers un objectif plus rapidement, tandis qu’une mauvaise heuristique peut conduire à des recherches inutiles.

    Structures de données:A* maintient deux structures de données principales : une liste ouverte (file d'attente prioritaire) et une liste fermée (ou pool visité). L'efficacité de ces structures de données, ainsi que l'implémentation choisie (par exemple, les tas binaires de file d'attente prioritaire), affectent les performances de l'algorithme.Facteur de branche :Le nombre moyen de followers pour chaque nœud affecte le nombre de nœuds développés lors de la recherche. Un facteur de branchement plus élevé peut conduire à davantage d’exploration, ce qui augmenteOptimalité et exhaustivité :A* garantit à la fois l’optimalité (trouver le chemin le plus court) et l’exhaustivité (trouver une solution qui existe). Cependant, cette garantie s’accompagne d’un compromis en termes de complexité de calcul, car l’algorithme doit explorer différentes voies pour des performances optimales. Concernant la complexité temporelle, la fonction heuristique choisie affecte A* dans le pire des cas. Avec une heuristique acceptée (qui ne surestime jamais le coût réel pour atteindre l'objectif), A* étend le moins de nœuds parmi les algorithmes d'optimisation. La complexité temporelle dans le pire des cas de A * est exponentielle dans le pire des cas O(b ^ d), où « b » est le facteur de branchement effectif (nombre moyen de suiveurs par nœud) et « d » est le facteur de branchement optimal.

En pratique, cependant, A* fonctionne souvent bien mieux en raison de l’influence d’une fonction heuristique qui aide à guider l’algorithme vers des voies prometteuses. Dans le cas d’une heuristique bien conçue, le facteur de branchement effectif est beaucoup plus petit, ce qui conduit à une approche plus rapide vers la solution optimale.