INFORMERTE SØKEALGORITMER I AI - KUNSTIG INTELLIGENS

En introduksjon til A*-søkealgoritme i AI

A* (uttales 'A-stjerne') er en kraftig grafovergang og banesøkende algoritme som er mye brukt innen kunstig intelligens og informatikk. Den brukes hovedsakelig til å finne den korteste veien mellom to noder i en graf, gitt den estimerte kostnaden for å komme fra gjeldende node til destinasjonsnoden. Den største fordelen med algoritmen er dens evne til å gi en optimal vei ved å utforske grafen på en mer informert måte sammenlignet med tradisjonelle søkealgoritmer som Dijkstras algoritme.

Algoritme A* kombinerer fordelene med to andre søkealgoritmer: Dijkstras algoritme og Greedy Best-First Search. I likhet med Dijkstras algoritme, sikrer A* at banen som er funnet er så kort som mulig, men gjør det mer effektivt ved å lede søket gjennom en heuristikk som ligner på Greedy Best-First Search. En heuristisk funksjon, betegnet h(n), estimerer kostnadene for å komme fra en gitt node n til destinasjonsnoden.

Hovedideen til A* er å evaluere hver node basert på to parametere:

sammenligne streng java

g(n):den faktiske kostnaden for å komme fra startnoden til noden n. Det representerer summen av kostnadene for node n utgående kanter.h(n):Heuristisk kostnad (også kjent som 'estimeringskostnad') fra node n til destinasjonsnode n. Denne problemspesifikke heuristiske funksjonen må være akseptabel, noe som betyr at den aldri overvurderer de faktiske kostnadene for å nå målet. Evalueringsfunksjonen til node n er definert som f(n) = g(n) h(n).

Algoritme A* velger nodene som skal utforskes basert på den laveste verdien av f(n), og foretrekker nodene med den laveste estimerte totale kostnaden for å nå målet. A*-algoritmen fungerer:

Lag en åpen liste over funne, men ikke utforskede noder.
Opprett en lukket liste for å inneholde allerede utforskede noder.
Legg til en startnode til den åpne listen med startverdien g
Gjenta følgende trinn til den åpne listen er tom eller du når målnoden:
1. Finn noden med den minste f-verdien (dvs. noden med minor g(n) h(n)) i den åpne listen.
2. Flytt den valgte noden fra den åpne listen til den lukkede listen.
3. Opprett alle gyldige etterkommere av den valgte noden.
4. For hver etterfølger beregner du g-verdien som summen av gjeldende nodes g-verdi og kostnadene ved å flytte fra gjeldende node til etterfølgernoden. Oppdater g-verdien til trackeren når en bedre sti er funnet.
5. Hvis følgeren ikke er på den åpne listen, legg den til med den beregnede g-verdien og beregn dens h-verdi. Hvis den allerede er i den åpne listen, oppdater g-verdien hvis den nye banen er bedre.
6. Gjenta syklusen. Algoritme A* avsluttes når målnoden er nådd eller når den åpne listen tømmes, noe som indikerer ingen veier fra startnoden til målnoden. A*-søkealgoritmen er mye brukt i ulike felt som robotikk, videospill, nettverksruting og designproblemer fordi den er effektiv og kan finne optimale veier i grafer eller nettverk.

Men å velge en egnet og akseptabel heuristisk funksjon er avgjørende for at algoritmen skal fungere riktig og gi en optimal løsning.

Historien om A*-søkealgoritmen i kunstig intelligens

Den ble utviklet av Peter Hart, Nils Nilsson og Bertram Raphael ved Stanford Research Institute (nå SRI International) som en forlengelse av Dijkstras algoritme og andre søkealgoritmer på den tiden. A* ble først utgitt i 1968 og fikk raskt anerkjennelse for sin betydning og effektivitet i kunstig intelligens og datavitenskap. Her er en kort oversikt over de mest kritiske milepælene i historien til søkealgoritmen A*:

Tidlige søkealgoritmer:Før utviklingen av A* eksisterte forskjellige grafsøkealgoritmer, inkludert Depth-First Search (DFS) og Breadth-First Search (BFS). Selv om disse algoritmene hjalp til med å finne stier, garanterer de ikke optimalitet eller vurderte heuristikk for å veilede søketDijkstras algoritme:I 1959 introduserte den nederlandske dataforskeren Edsger W. Dijkstra Dijkstras algoritme, som fant den korteste veien i en vektet graf med ikke-negative kantvekter. Dijkstras algoritme var effektiv, men på grunn av sin uttømmende natur hadde den begrensninger når den ble brukt på større grafer ellerInformert søk:Kunnskapsbaserte søkealgoritmer (også kjent som heuristisk søk) er utviklet for å inkludere heuristisk informasjon, for eksempel estimerte kostnader, for å veilede søkeprosessen effektivt. Greedy Best-First Search var en slik algoritme, men den garanterte ikke optimalitet for å finne den korteste veien.A* utvikling:I 1968 introduserte Peter Hart, Nils Nilsson og Bertram Raphael A*-algoritmen som en kombinasjon av Dijkstras algoritme og Greedy Best-First Search. A* brukte en heuristisk funksjon for å estimere kostnadene fra gjeldende node til destinasjonsnoden ved å kombinere den med den faktiske kostnaden for å nå gjeldende node. Dette tillot A* å utforske grafen mer bevisst, unngå unødvendige stier og garantere en optimal løsning.Rettferdighet og fullkommenhet:Forfatterne av A* viste at algoritmen er perfekt (finner alltid en løsning hvis en finnes) og optimal (finner den korteste veien) under visse forhold.Utbredt adopsjon og fremgang:A* ble raskt populær i AI- og IT-miljøene på grunn av effektiviteten, og forskere og utviklere har utvidet og brukt A*-algoritmen til forskjellige felt, inkludert robotikk, videospill, engineering og nettverksruting. Flere variasjoner og optimaliseringer av A*-algoritmen har blitt foreslått i løpet av årene, for eksempel Incremental A* og Parallel A*. I dag er A*-søkealgoritmen fortsatt en grunnleggende og mye brukt algoritme innen kunstig intelligens og grafovergang. Det fortsetter å spille en viktig rolle i ulike applikasjoner og forskningsfelt. Dens innvirkning på kunstig intelligens og dens bidrag til stifinning og optimaliseringsproblemer har gjort den til en hjørnesteinsalgoritme i forskning på intelligente systemer.

Hvordan fungerer A*-søkealgoritmen i kunstig intelligens?

A* (uttales 'bokstav A')-søkealgoritmen er en populær og mye brukt graftraversalalgoritme innen kunstig intelligens og informatikk. Den brukes til å finne den korteste veien fra en startnode til en destinasjonsnode i en vektet graf. A* er en informert søkealgoritme som bruker heuristikk for å veilede søket effektivt. Søkealgoritmen A* fungerer som følger:

Algoritmen starter med en prioritert kø for å lagre nodene som skal utforskes. Den instansierer også to datastrukturer g(n): Kostnaden for den korteste veien så langt fra startnoden til noden n og h(n), den estimerte kostnaden (heuristisk) fra noden n til destinasjonsnoden. Det er ofte en rimelig heuristikk, noe som betyr at den aldri overvurderer de faktiske kostnadene ved å oppnå et mål. Sett startnoden i prioritetskøen og sett dens g(n) til 0. Hvis prioritetskøen ikke er tom, Fjern noden med lavest f(n) fra prioritetskøen. f(n) = g(n) h(n). Hvis den slettede noden er målnoden, avsluttes algoritmen, og banen blir funnet. Ellers utvider du noden og oppretter dens naboer. For hver nabonode beregner du dens innledende g(n)-verdi, som er summen av g-verdien til den nåværende noden og kostnadene ved å flytte fra den nåværende noden til en nabonode. Hvis nabonoden ikke er i prioritert rekkefølge eller den opprinnelige g(n)-verdien er mindre enn gjeldende g-verdi, oppdater g-verdien og sett overordnet node til gjeldende node. Beregn f(n)-verdien fra nabonoden og legg den til prioritetskøen.

Hvis syklusen avsluttes uten å finne destinasjonsnoden, har grafen ingen bane fra start til slutt. Nøkkelen til effektiviteten til A* er bruken av en heuristisk funksjon h(n) som gir et estimat av gjenværende kostnad for å nå målet til en hvilken som helst node. Ved å kombinere den faktiske kostnaden g (n) med den heuristiske kostnaden h (n), utforsker algoritmen effektivt lovende veier, og prioriterer noder som sannsynligvis vil føre til den korteste veien. Det er viktig å merke seg at effektiviteten til A*-algoritmen er svært avhengig av valget av den heuristiske funksjonen. Akseptable heuristikk sikrer at algoritmen alltid finner den korteste veien, men mer informert og nøyaktig heuristikk kan føre til raskere konvergens og redusert søkerom.

Fordeler med A*-søkealgoritme i kunstig intelligens

A*-søkealgoritmen tilbyr flere fordeler i kunstig intelligens og problemløsningsscenarier:

Optimal løsning:A* sikrer å finne den optimale (korteste) veien fra startnoden til destinasjonsnoden i den vektede grafen gitt en akseptabel heuristisk funksjon. Denne optimaliteten er en avgjørende fordel i mange applikasjoner der det er viktig å finne den korteste veien.Fullstendighet:Hvis det finnes en løsning, vil A* finne den, forutsatt at grafen ikke har en uendelig kostnad. Denne fullstendighetsegenskapen sikrer at A* kan dra nytte av en løsning hvis den finnes.Effektivitet:A* er effektiv hvis effektiv og akseptabel heuristisk funksjon brukes. Heuristikk veileder søket til et mål ved å fokusere på lovende veier og unngå unødvendig utforskning, noe som gjør A* mer effektiv enn ikke-bevisste søkealgoritmer som bredde-først-søk eller dybde-først-søk.Allsidighet:A* er allment anvendelig for ulike problemområder, inkludert veifinning, ruteplanlegging, robotikk, spillutvikling og mer. A* kan brukes til å finne optimale løsninger effektivt så lenge en meningsfull heuristikk kan defineres.Optimalisert søk:A* opprettholder en prioritert rekkefølge for å velge nodene med den mindre f(n)-verdien (g(n) og h(n)) for utvidelse. Dette lar den utforske lovende stier først, noe som reduserer søkeområdet og fører til raskere konvergens.Minneeffektivitet:I motsetning til noen andre søkealgoritmer, for eksempel bredde-først-søk, lagrer A* bare et begrenset antall noder i prioritetskøen, noe som gjør den minneeffektiv, spesielt for store grafer.Justerbar heuristikk:A*s ytelse kan finjusteres ved å velge forskjellige heuristiske funksjoner. Mer utdannet heuristikk kan føre til raskere konvergens og mindre utvidede noder.Mye undersøkt:A* er en veletablert algoritme med flere tiår med forskning og praktiske anvendelser. Mange optimaliseringer og variasjoner er utviklet, noe som gjør det til et pålitelig og godt forstått feilsøkingsverktøy.Nettsøk:A* kan brukes til nettbasert stisøk, hvor algoritmen hele tiden oppdaterer banen i henhold til endringer i miljøet eller utseendet til nye. Det muliggjør sanntids beslutningstaking i dynamiske scenarier.

Ulemper med A*-søkealgoritme i kunstig intelligens

Selv om A* (bokstav A) søkealgoritmen er en mye brukt og kraftig teknikk for å løse AI-banesøking og grafovergangproblemer, har den ulemper og begrensninger. Her er noen av de største ulempene med søkealgoritmen:

Heuristisk nøyaktighet:Ytelsen til A*-algoritmen avhenger sterkt av nøyaktigheten til den heuristiske funksjonen som brukes til å estimere kostnaden fra gjeldende node til Hvis heuristikken er uakseptabel (overvurderer aldri den faktiske kostnaden) eller inkonsistent (tilfredsstiller trekantens ulikhet), A* finner kanskje ikke en optimal vei eller kan utforske flere noder enn nødvendig, noe som påvirker effektiviteten og nøyaktigheten.Minnebruk:A* krever at alle besøkte noder holdes i minnet for å holde styr på utforskede stier. Minnebruk kan noen ganger bli et betydelig problem, spesielt når du har å gjøre med en god søkeplass eller begrensede minneressurser.Tidskompleksitet:Selv om A* generelt er effektiv, kan tidskompleksiteten være et problem for store søkeområder eller grafer. I verste fall kan det ta eksponentielt lengre tid for A* å finne den optimale banen hvis heuristikken er upassende for problemet.Flaskehals på destinasjonen:I spesifikke scenarier må A*-algoritmen utforske noder langt fra destinasjonen før den endelig når destinasjonsregionen. Dette problemet oppstår når heuristikken trenger å rette søket mot målet tidlig effektivt.Kostnadsbinding:A* møter vanskeligheter når flere noder har samme f-verdi (summen av den faktiske kostnaden og den heuristiske kostnaden). Strategien som brukes kan påvirke optimaliteten og effektiviteten til den oppdagede banen. Hvis det ikke håndteres riktig, kan det føre til at unødvendige noder utforskes og bremse algoritmen.Kompleksitet i dynamiske miljøer:I dynamiske miljøer der kostnadene for kanter eller noder kan endre seg under søket, kan det hende at A* ikke er egnet fordi den ikke tilpasser seg godt til slike endringer. Reformulering fra bunnen av kan være beregningsmessig kostbart, og D* (Dynamic A*) algoritmer ble utviklet for å løse dettePerfeksjon i uendelig plass:A* finner kanskje ikke en løsning i uendelig tilstandsrom. I slike tilfeller kan den kjøre på ubestemt tid, og utforske et stadig økende antall noder uten å finne en løsning. Til tross for disse manglene er A* fortsatt en robust og mye brukt algoritme fordi den effektivt kan finne optimale veier i mange praktiske situasjoner dersom den heuristiske funksjonen er godt utformet og søkerommet er håndterbart. Ulike variasjoner og varianter av A* har blitt foreslått for å lindre noen av dens begrensninger.

Anvendelser av A*-søkealgoritmen i kunstig intelligens

Søkealgoritmen A* (bokstav A) er en mye brukt og robust stifinnende algoritme innen kunstig intelligens og informatikk. Dens effektivitet og optimalitet gjør den egnet for ulike bruksområder. Her er noen typiske anvendelser av A*-søkealgoritmen i kunstig intelligens:

dhanashree verma

Veier i spill:A* brukes ofte i videospill for bevegelse av karakterer, fiendtlig AI-navigasjon og for å finne den korteste veien fra ett sted til et annet på spillkartet. Dens evne til å finne den optimale banen basert på kostnader og heuristikk gjør den ideell for sanntidsapplikasjoner som spill.Robotikk og autonome kjøretøy:A* brukes i robotikk og autonom kjøretøynavigasjon for å planlegge en optimal rute for roboter for å nå en destinasjon, unngå hindringer og vurdere terrengkostnader. Dette er avgjørende for effektiv og sikker bevegelse i naturlige miljøer.Labyrintløsning:A* kan effektivt finne den korteste veien gjennom en labyrint, noe som gjør den verdifull i mange labyrintløsningsapplikasjoner, for eksempel å løse gåter eller navigere i komplekse strukturer.Ruteplanlegging og navigering:I GPS-systemer og kartapplikasjoner kan A* brukes til å finne den optimale ruten mellom to punkter på et kart, med tanke på faktorer som avstand, trafikkforhold og veinettets topologi.Løse gåter:A* kan løse ulike diagramoppgaver, for eksempel skyveoppgaver, Sudoku og 8-puslespillet. Ressursallokering: I scenarier der ressursene må allokeres optimalt, kan A* hjelpe med å finne den mest effektive allokeringsveien, minimere kostnadene og maksimere effektiviteten.Nettverksruting:A* kan brukes i datanettverk for å finne den mest effektive ruten for datapakker fra en kilde til en destinasjonsnode.Naturlig språkbehandling (NLP):I noen NLP-oppgaver kan A* generere sammenhengende og kontekstuelle svar ved å søke etter mulige ordsekvenser basert på deres sannsynlighet og relevans.Baneplanlegging i robotikk:A* kan brukes til å planlegge banen til en robot fra ett punkt til et annet, med tanke på ulike begrensninger, for eksempel å unngå hindringer eller minimere energiforbruket.Spill AI:A* brukes også til å ta intelligente avgjørelser for ikke-spillerkarakterer (NPC), for eksempel å bestemme den beste måten å nå et mål på eller koordinere bevegelser i et lagbasert spill.

Dette er bare noen få eksempler på hvordan A*-søkealgoritmen finner applikasjoner innen ulike områder av kunstig intelligens. Dens fleksibilitet, effektivitet og optimalisering gjør den til et verdifullt verktøy for mange problemer.

C-program for A*-søkealgoritme i kunstig intelligens

 #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 for A* Search Algorithm in Artificial Intelligence

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

Forklaring:

startnoden til banen.

Eksempelutgang

 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 for 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* Søkealgoritmekompleksitet i kunstig intelligens

A* (uttales 'A-stjerne') søkealgoritme er en populær og mye brukt grafovergang og banesøkealgoritme innen kunstig intelligens. Å finne den korteste veien mellom to noder i et graf- eller rutenettbasert miljø er vanligvis vanlig. Algoritmen kombinerer Dijkstras og grådige best-first-søkeelementer for å utforske søkeområdet samtidig som den sikrer optimalitet effektivt. Flere faktorer bestemmer kompleksiteten til A*-søkealgoritmen. Grafstørrelse (noder og kanter): En grafs antall noder og kanter påvirker i stor grad algoritmens kompleksitet. Flere noder og kanter betyr flere mulige alternativer å utforske, noe som kan øke utførelsestiden til algoritmen.

Heuristisk funksjon: A* bruker en heuristisk funksjon (ofte betegnet h(n)) for å estimere kostnaden fra gjeldende node til destinasjonsnoden. Presisjonen til denne heuristikken påvirker i stor grad effektiviteten til A*-søket. En god heuristikk kan hjelpe søket til et mål raskere, mens en dårlig heuristikk kan føre til unødvendig søking.

Datastrukturer:A* opprettholder to hoveddatastrukturer: en åpen liste (prioritetskø) og en lukket liste (eller besøkt pool). Effektiviteten til disse datastrukturene, sammen med den valgte implementeringen (f.eks. binære hauger i prioritert kø), påvirker algoritmens ytelse.Grenfaktor:Gjennomsnittlig antall følgere for hver node påvirker antallet noder som utvides under søket. En høyere forgreningsfaktor kan føre til mer leting, som økerOptimalitet og fullstendighet:A* garanterer både optimalitet (finne den korteste veien) og fullstendighet (finne en løsning som finnes). Denne garantien kommer imidlertid med en avveining når det gjelder beregningsmessig kompleksitet, da algoritmen må utforske ulike veier for optimal ytelse. Når det gjelder tidskompleksitet, påvirker den valgte heuristiske funksjonen A* i verste fall. Med en akseptert heuristikk (som aldri overvurderer den sanne kostnaden for å nå målet), utvider A* de færreste nodene blant optimaliseringsalgoritmene. Den verste tidskompleksiteten til A * er eksponentiell i det verste tilfellet O(b ^ d), der 'b' er den effektive forgreningsfaktoren (gjennomsnittlig antall følgere per node) og 'd' er den optimale

I praksis presterer imidlertid A* ofte betydelig bedre på grunn av påvirkningen fra en heuristisk funksjon som hjelper til med å lede algoritmen til lovende baner. Ved en godt utformet heuristikk er den effektive forgreningsfaktoren mye mindre, noe som fører til en raskere tilnærming til den optimale løsningen.

TechCodeview

A* Søkealgoritme i kunstig intelligens