logo

A* Algoritmus hledání v umělé inteligenci

Úvod do A* vyhledávacího algoritmu v AI

A* (vyslovuje se 'A-star') je výkonný algoritmus pro procházení grafů a hledání cest široce používaný v umělé inteligenci a počítačové vědě. Používá se hlavně k nalezení nejkratší cesty mezi dvěma uzly v grafu s ohledem na odhadované náklady na cestu z aktuálního uzlu do cílového uzlu. Hlavní výhodou algoritmu je jeho schopnost poskytovat optimální cestu prozkoumáváním grafu informovanějším způsobem ve srovnání s tradičními vyhledávacími algoritmy, jako je Dijkstrův algoritmus.

Algoritmus A* kombinuje výhody dvou dalších vyhledávacích algoritmů: Dijkstrův algoritmus a Greedy Best-First Search. Stejně jako Dijkstrův algoritmus, A* zajišťuje, že nalezená cesta je co nejkratší, ale dělá to efektivněji tím, že nasměruje své hledání pomocí heuristiky podobné Greedy Best-First Search. Heuristická funkce, označovaná h(n), odhaduje náklady na přechod z libovolného daného uzlu n do cílového uzlu.

Hlavní myšlenkou A* je vyhodnotit každý uzel na základě dvou parametrů:

ipconfig pro linux zdarma
    g(n):skutečné náklady na přechod z počátečního uzlu do uzlu n. Představuje součet nákladů uzlu n odchozích hran.h(n):Heuristické náklady (také známé jako „náklady na odhad“) z uzlu n do cílového uzlu n. Tato heuristická funkce specifická pro problém musí být přijatelná, což znamená, že nikdy nepřeceňuje skutečné náklady na dosažení cíle. Vyhodnocovací funkce uzlu n je definována jako f(n) = g(n) h(n).

Algoritmus A* vybírá uzly, které mají být prozkoumány, na základě nejnižší hodnoty f(n), přičemž dává přednost uzlům s nejnižšími odhadovanými celkovými náklady na dosažení cíle. Algoritmus A* funguje:

  1. Vytvořte otevřený seznam nalezených, ale neprozkoumaných uzlů.
  2. Vytvořte uzavřený seznam pro uložení již prozkoumaných uzlů.
  3. Přidejte počáteční uzel do otevřeného seznamu s počáteční hodnotou g
  4. Opakujte následující kroky, dokud není otevřený seznam prázdný nebo dokud nedosáhnete cílového uzlu:
    1. Najděte uzel s nejmenší f-hodnotou (tj. uzel s vedlejším g(n) h(n)) v otevřeném seznamu.
    2. Přesuňte vybraný uzel z otevřeného seznamu do uzavřeného seznamu.
    3. Vytvořte všechny platné potomky vybraného uzlu.
    4. Pro každého následníka se vypočítá jeho g-hodnota jako součet hodnoty g aktuálního uzlu a nákladů na přesun z aktuálního uzlu na uzel následníka. Aktualizujte g-hodnotu sledovače, když je nalezena lepší cesta.
    5. Pokud sledovač není v otevřeném seznamu, přidejte jej s vypočítanou hodnotou g a vypočítejte jeho hodnotu h. Pokud je již v otevřeném seznamu, aktualizujte jeho hodnotu g, pokud je nová cesta lepší.
    6. Opakujte cyklus. Algoritmus A* končí, když je dosaženo cílového uzlu nebo když se otevřený seznam vyprázdní, což neindikuje žádné cesty od počátečního uzlu k cílovému uzlu. Algoritmus hledání A* je široce používán v různých oblastech, jako je robotika, videohry, síťové směrování a problémy s návrhem, protože je efektivní a dokáže najít optimální cesty v grafech nebo sítích.

Volba vhodné a přijatelné heuristické funkce je však zásadní, aby algoritmus fungoval správně a poskytoval optimální řešení.

Informované vyhledávací algoritmy

Historie A* vyhledávacího algoritmu v umělé inteligenci

Byl vyvinut Peterem Hartem, Nilsem Nilssonem a Bertramem Raphaelem ve Stanford Research Institute (nyní SRI International) jako rozšíření Dijkstrova algoritmu a dalších vyhledávacích algoritmů té doby. A* byl poprvé publikován v roce 1968 a rychle získal uznání pro svůj význam a účinnost v komunitách umělé inteligence a počítačových věd. Zde je stručný přehled nejkritičtějších milníků v historii vyhledávacího algoritmu A*:

    Rané vyhledávací algoritmy:Před vývojem A* existovaly různé algoritmy prohledávání grafů, včetně Depth-First Search (DFS) a Breadth-First Search (BFS). I když tyto algoritmy pomohly najít cesty, nezaručovaly optimalitu ani nezohledňovaly heuristiku jako vodítko pro hledání.Dijkstrův algoritmus:V roce 1959 holandský počítačový vědec Edsger W. Dijkstra představil Dijkstrův algoritmus, který našel nejkratší cestu ve váženém grafu s nezápornými váhami hran. Dijkstrův algoritmus byl efektivní, ale vzhledem ke své vyčerpávající povaze měl omezení při použití na větších grafech resp.Informované vyhledávání:Algoritmy vyhledávání založené na znalostech (také známé jako heuristické vyhledávání) byly vyvinuty tak, aby zahrnovaly heuristické informace, jako jsou odhadované náklady, pro efektivní vedení procesu vyhledávání. Greedy Best-First Search byl jedním z takových algoritmů, ale nezaručoval optimalitu pro nalezení nejkratší cesty.A* vývoj:V roce 1968 Peter Hart, Nils Nilsson a Bertram Raphael představili algoritmus A* jako kombinaci Dijkstrova algoritmu a Greedy Best-First Search. A* použil heuristickou funkci k odhadu nákladů z aktuálního uzlu do cílového uzlu jejich kombinací se skutečnými náklady na dosažení aktuálního uzlu. To umožnilo A* prozkoumat graf vědoměji, vyhnout se zbytečným cestám a zaručit optimální řešení.Spravedlnost a dokonalost:Autoři A* ukázali, že algoritmus je dokonalý (vždy najde řešení, pokud nějaké existuje) a optimální (najde nejkratší cestu) za určitých podmínek.Široké přijetí a pokrok:A* si rychle získal oblibu v komunitách AI a IT díky své efektivitě a výzkumníci a vývojáři rozšířili a aplikovali algoritmus A* v různých oblastech, včetně robotiky, videoher, inženýrství a síťového směrování. V průběhu let bylo navrženo několik variací a optimalizací algoritmu A*, jako je Incremental A* a Parallel A*. Dnes je vyhledávací algoritmus A* stále základním a široce používaným algoritmem v umělé inteligenci a procházení grafů. Nadále hraje zásadní roli v různých aplikacích a oblastech výzkumu. Jeho dopad na umělou inteligenci a jeho příspěvek k problémům s hledáním cest a optimalizací z něj udělaly základní kámen algoritmu ve výzkumu inteligentních systémů.

Jak funguje vyhledávací algoritmus A* v umělé inteligenci?

Algoritmus hledání A* (vyslovuje se jako „písmeno A“) je populární a široce používaný algoritmus procházení grafů v umělé inteligenci a počítačové vědě. Používá se k nalezení nejkratší cesty z počátečního uzlu do cílového uzlu ve váženém grafu. A* je informovaný vyhledávací algoritmus, který využívá heuristiku k efektivnímu vedení vyhledávání. Algoritmus hledání A* funguje následovně:

Algoritmus začíná prioritní frontou pro uložení uzlů, které mají být prozkoumány. Také vytváří instanci dvou datových struktur g(n): Cena dosud nejkratší cesty od počátečního uzlu k uzlu n a h(n), odhadovaná cena (heuristika) z uzlu n do cílového uzlu. Často jde o rozumnou heuristiku, což znamená, že nikdy nepřeceňuje skutečné náklady na dosažení cíle. Vložte počáteční uzel do fronty s prioritou a nastavte jeho g(n) na 0. Pokud fronta s prioritou není prázdná, odstraňte uzel s nejnižší f(n) z fronty s prioritou. f(n) = g(n) h(n). Pokud je odstraněný uzel cílovým uzlem, algoritmus skončí a je nalezena cesta. V opačném případě rozbalte uzel a vytvořte jeho sousedy. Pro každý sousední uzel vypočítejte jeho počáteční hodnotu g(n), což je součet hodnoty g aktuálního uzlu a nákladů na přesun z aktuálního uzlu do sousedního uzlu. Pokud sousední uzel není v pořadí priority nebo je původní hodnota g(n) menší než jeho aktuální hodnota g, aktualizujte jeho hodnotu g a nastavte jeho nadřazený uzel na aktuální uzel. Vypočítejte hodnotu f(n) ze sousedního uzlu a přidejte ji do prioritní fronty.

Pokud cyklus skončí bez nalezení cílového uzlu, graf nemá žádnou cestu od začátku do konce. Klíčem k efektivitě A* je jeho použití heuristické funkce h(n), která poskytuje odhad zbývajících nákladů na dosažení cíle jakéhokoli uzlu. Kombinací skutečných nákladů g (n) s heuristickými náklady h (n) algoritmus efektivně zkoumá slibné cesty a upřednostňuje uzly, které pravděpodobně povedou k nejkratší cestě. Je důležité poznamenat, že účinnost A* algoritmu je vysoce závislá na volbě heuristické funkce. Přijatelná heuristika zajišťuje, že algoritmus vždy najde nejkratší cestu, ale informovanější a přesnější heuristika může vést k rychlejší konvergenci a zmenšení prostoru pro vyhledávání.

Výhody A* vyhledávacího algoritmu v umělé inteligenci

Algoritmus hledání A* nabízí několik výhod ve scénářích umělé inteligence a řešení problémů:

    Optimální řešení:A* zajišťuje nalezení optimální (nejkratší) cesty od počátečního uzlu k cílovému uzlu ve váženém grafu za předpokladu přijatelné heuristické funkce. Tato optimalita je rozhodující výhodou v mnoha aplikacích, kde je zásadní najít nejkratší cestu.Úplnost:Pokud řešení existuje, A* ho najde, za předpokladu, že graf nemá nekonečnou cenu. Tato vlastnost úplnosti zajišťuje, že A* může využít řešení, pokud existuje.Účinnost:A* je efektivní při použití efektivní a přijatelné heuristické funkce. Heuristika vede hledání k cíli tím, že se zaměřuje na slibné cesty a vyhýbá se zbytečnému prozkoumávání, díky čemuž je A* efektivnější než nevědomé vyhledávací algoritmy, jako je prohledávání do šířky nebo prohledávání do hloubky.Všestrannost:A* je široce použitelný v různých problémových oblastech, včetně hledání cesty, plánování trasy, robotiky, vývoje her a dalších. A* lze použít k efektivnímu nalezení optimálních řešení, pokud lze definovat smysluplnou heuristiku.Optimalizované vyhledávání:A* udržuje pořadí priority pro výběr uzlů s vedlejší hodnotou f(n) (g(n) a h(n)) pro expanzi. To mu umožňuje nejprve prozkoumat slibné cesty, což snižuje prostor pro vyhledávání a vede k rychlejší konvergenci.Výkon paměti:Na rozdíl od některých jiných vyhledávacích algoritmů, jako je prohledávání do šířky, A* ukládá do prioritní fronty pouze omezený počet uzlů, což umožňuje efektivní paměť, zejména u velkých grafů.Nastavitelná heuristika:Výkon A* lze doladit výběrem různých heuristických funkcí. Vzdělanější heuristika může vést k rychlejší konvergenci a méně rozšířeným uzlům.Důkladně prozkoumáno:A* je dobře zavedený algoritmus s desetiletími výzkumu a praktických aplikací. Bylo vyvinuto mnoho optimalizací a variací, díky kterým je spolehlivý a dobře srozumitelný nástroj pro odstraňování problémů.Webové vyhledávání:A* lze použít pro webové vyhledávání cest, kde algoritmus neustále aktualizuje cestu podle změn v prostředí nebo vzhledu nového Umožňuje rozhodování v reálném čase v dynamických scénářích.

Nevýhody A* vyhledávacího algoritmu v umělé inteligenci

Přestože je vyhledávací algoritmus A* (písmeno A) široce používanou a výkonnou technikou pro řešení problémů s hledáním cesty a procházením grafů, má své nevýhody a omezení. Zde jsou některé z hlavních nevýhod vyhledávacího algoritmu:

    Heuristická přesnost:Výkon algoritmu A* závisí do značné míry na přesnosti heuristické funkce použité k odhadu nákladů z aktuálního uzlu do Pokud je heuristika nepřijatelná (nikdy nepřeceňuje skutečné náklady) nebo nekonzistentní (vyhovuje trojúhelníkové nerovnosti), A* nemusí najít optimální cestu nebo může prozkoumat více uzlů, než je nutné, což ovlivňuje jeho účinnost a přesnost.Využití paměti:A* vyžaduje, aby byly všechny navštívené uzly uchovávány v paměti, aby bylo možné sledovat prozkoumané cesty. Využití paměti se někdy může stát závažným problémem, zejména pokud se jedná o dostatek místa pro vyhledávání nebo omezené paměťové zdroje.Časová složitost:Ačkoli A* je obecně efektivní, jeho časová složitost může být problémem pro rozsáhlé vyhledávací prostory nebo grafy. V nejhorším případě může A* trvat exponenciálně déle, než najde optimální cestu, pokud je heuristika pro daný problém nevhodná.Úzké místo v cíli:Ve specifických scénářích musí algoritmus A* prozkoumat uzly daleko od cíle, než konečně dosáhne cílové oblasti. Tento problém nastává, když heuristika potřebuje včas efektivně nasměrovat hledání k cíli.Vazba nákladů:A* čelí potížím, když více uzlů má stejnou f-hodnotu (součet skutečných nákladů a heuristických nákladů). Použitá strategie může ovlivnit optimalitu a efektivitu objevené cesty. Pokud není správně zpracováno, může to vést k prozkoumávání nepotřebných uzlů a zpomalení algoritmu.Složitost v dynamických prostředích:V dynamických prostředích, kde se cena hran nebo uzlů může během vyhledávání měnit, nemusí být A* vhodné, protože se na takové změny špatně adaptuje. Reformulace od nuly může být výpočetně nákladná a algoritmy D* (Dynamic A*) byly navrženy tak, aby to vyřešily.Dokonalost v nekonečném prostoru:A* nemusí najít řešení v nekonečném stavovém prostoru. V takových případech může běžet neomezeně dlouho a prozkoumávat stále větší počet uzlů bez nalezení řešení. Navzdory těmto nedostatkům je A* stále robustním a široce používaným algoritmem, protože dokáže efektivně najít optimální cesty v mnoha praktických situacích, pokud je heuristická funkce dobře navržena a vyhledávací prostor je zvládnutelný. Pro zmírnění některých jeho omezení byly navrženy různé variace a varianty A*.

Aplikace A* vyhledávacího algoritmu v umělé inteligenci

Vyhledávací algoritmus A* (písmeno A) je široce používaný a robustní algoritmus hledání cesty v umělé inteligenci a počítačové vědě. Díky své účinnosti a optimalitě je vhodný pro různé aplikace. Zde jsou některé typické aplikace vyhledávacího algoritmu A* v umělé inteligenci:

    Hledání cesty ve hrách:A* se často používá ve videohrách pro pohyb postav, nepřátelskou AI navigaci a hledání nejkratší cesty z jednoho místa na druhé na herní mapě. Jeho schopnost najít optimální cestu na základě nákladů a heuristiky je ideální pro aplikace v reálném čase, jako jsou hry.Robotika a autonomní vozidla:A* se používá v robotice a autonomní navigaci vozidel k plánování optimální trasy pro roboty k dosažení cíle, vyhýbání se překážkám a zvážení nákladů na terén. To je zásadní pro efektivní a bezpečný pohyb v přirozeném prostředí.Řešení bludiště:A* dokáže efektivně najít nejkratší cestu bludištěm, díky čemuž je cenný v mnoha aplikacích pro řešení bludišť, jako je řešení hádanek nebo navigace ve složitých strukturách.Plánování trasy a navigace:V systémech GPS a mapových aplikacích lze A* použít k nalezení optimální trasy mezi dvěma body na mapě s ohledem na faktory, jako je vzdálenost, dopravní podmínky a topologie silniční sítě.Řešení hádanek:A* dokáže vyřešit různé logické hádanky, jako jsou posuvné hádanky, sudoku a problém s 8 hádankami. Alokace zdrojů: Ve scénářích, kde musí být zdroje optimálně alokovány, může A* pomoci najít nejefektivnější cestu alokace, minimalizovat náklady a maximalizovat efektivitu.Směrování sítě:A* lze použít v počítačových sítích k nalezení nejefektivnější cesty pro datové pakety ze zdroje do cílového uzlu.Zpracování přirozeného jazyka (NLP):V některých úlohách NLP může A* generovat koherentní a kontextové odpovědi hledáním možných sekvencí slov na základě jejich pravděpodobnosti a relevance.Plánování cesty v robotice:A* lze použít k plánování cesty robota z jednoho bodu do druhého s ohledem na různá omezení, jako je vyhýbání se překážkám nebo minimalizace spotřeby energie.Herní AI:A* se také používá k inteligentním rozhodnutím pro nehráčské postavy (NPC), jako je určování nejlepšího způsobu dosažení cíle nebo koordinace pohybů v týmové hře.

To je jen několik příkladů toho, jak vyhledávací algoritmus A* nachází uplatnění v různých oblastech umělé inteligence. Jeho flexibilita, efektivita a optimalizace z něj činí cenný nástroj pro mnoho problémů.

C program pro A* vyhledávací algoritmus v umělé inteligenci

 #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)>

C++ program pro A* vyhledávací algoritmus v umělé inteligenci

 #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>

Vysvětlení:

    Uzel struktury:To definuje strukturu uzlu, která představuje buňku mřížky. Obsahuje souřadnice x a y uzlu, cenu g od počátečního uzlu k tomuto uzlu, heuristickou hodnotu h (odhadované náklady z tohoto uzlu do cílového uzlu) a ukazatel na
  1. počáteční uzel cesty.
  2. Vypočítat heuristiku:Tato funkce vypočítá heuristiku pomocí euklidovské vzdálenosti mezi uzlem a cílem AStarSearch: Tato funkce spustí vyhledávací algoritmus A*. Vezme počáteční a cílové souřadnice, mřížku a vrátí vektor párů představující souřadnice nejkratší cesty od začátku do konce.Hlavní:Hlavní funkce programu přebírá vstupní mřížky, počátek a cílové souřadnice od uživatele. Poté zavolá AStarSearch, aby nalezl nejkratší cestu a vytiskl výsledek. Struct Node: Definuje strukturu uzlu, která představuje buňku mřížky. Obsahuje souřadnice x a y uzlu, cenu g od počátečního uzlu k tomuto uzlu, heuristickou hodnotu h (odhadovaná cena z tohoto uzlu do cílového uzlu) a ukazatel na počáteční uzel cesty.Vypočítejte heuristiku:Tato funkce vypočítává heuristiku pomocí euklidovské vzdálenosti mezi uzlem a cílem AStarSearch: Tato funkce spouští vyhledávací algoritmus A*. Vezme počáteční a cílové souřadnice, mřížku a vrátí vektor párů představující souřadnice nejkratší cesty od začátku do konce.

Ukázkový výstup

 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 

Java program pro A* Search Algorithm in Artificial Intelligence

 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* Složitost vyhledávacího algoritmu v umělé inteligenci

Algoritmus hledání A* (vyslovuje se 'A-star') je populární a široce používaný algoritmus procházení grafů a hledání cest v umělé inteligenci. Nalezení nejkratší cesty mezi dvěma uzly v prostředí založeném na grafu nebo mřížce je obvykle běžné. Algoritmus kombinuje prvky vyhledávání Dijkstra a chamtivé prvky best-first, aby prozkoumal vyhledávací prostor a zároveň efektivně zajistil optimalitu. Složitost vyhledávacího algoritmu A* určuje několik faktorů. Velikost grafu (uzly a hrany): Počet uzlů a hran grafu výrazně ovlivňuje složitost algoritmu. Více uzlů a hran znamená více možností k prozkoumání, což může prodloužit dobu provádění algoritmu.

Heuristická funkce: A* používá heuristickou funkci (často označovanou h(n)) k odhadu nákladů z aktuálního uzlu do cílového uzlu. Přesnost této heuristiky výrazně ovlivňuje efektivitu A* vyhledávání. Dobrá heuristika může pomoci navést hledání k cíli rychleji, zatímco špatná heuristika může vést ke zbytečnému hledání.

    Datové struktury:A* udržuje dvě struktury hlavních dat: otevřený seznam (prioritní fronta) a uzavřený seznam (neboli navštívený fond). Účinnost těchto datových struktur spolu se zvolenou implementací (např. binární haldy prioritních front) ovlivňuje výkon algoritmu.Faktor větve:Průměrný počet sledujících pro každý uzel ovlivňuje počet uzlů rozbalených během vyhledávání. Vyšší faktor větvení může vést k většímu průzkumu, který se zvyšujeOptimalita a úplnost:A* zaručuje jak optimalitu (nalezení nejkratší cesty), tak úplnost (nalezení existujícího řešení). Tato záruka však přichází s kompromisem, pokud jde o výpočetní složitost, protože algoritmus musí pro optimální výkon prozkoumat různé cesty. Pokud jde o časovou složitost, zvolená heuristická funkce ovlivňuje v nejhorším případě A*. Díky akceptované heuristice (která nikdy nepřeceňuje skutečné náklady na dosažení cíle) A* rozšiřuje nejmenší počet uzlů mezi optimalizačními algoritmy. Časová složitost A * v nejhorším případě je exponenciální v nejhorším případě O(b ^ d), kde „b“ je efektivní faktor větvení (průměrný počet následovníků na uzel) a „d“ je optimální

V praxi však A* často funguje výrazně lépe díky vlivu heuristické funkce, která pomáhá vést algoritmus slibnými cestami. V případě dobře navržené heuristiky je efektivní faktor větvení mnohem menší, což vede k rychlejšímu přístupu k optimálnímu řešení.

virtuální paměť