Увод у А* алгоритам претраживања у АИ

А* (изговара се 'А-звезда') је моћан алгоритам за обилажење графова и проналажење путање који се широко користи у вештачкој интелигенцији и рачунарским наукама. Углавном се користи за проналажење најкраћег пута између два чвора на графу, с обзиром на процењену цену доласка од тренутног чвора до одредишног чвора. Главна предност алгоритма је његова способност да обезбеди оптималну путању истраживањем графа на боље информисан начин у поређењу са традиционалним алгоритмима за претрагу као што је Дијкстрин алгоритам.

Алгоритам А* комбинује предности два друга алгоритма претраге: Дијкстриног алгоритма и Грееди Бест-Фирст Сеарцх. Попут Дијкстриног алгоритма, А* осигурава да је пронађена путања што краћа, али то чини ефикасније усмеравајући своју претрагу кроз хеуристику сличну Грееди Бест-Фирст Сеарцх. Хеуристичка функција, означена са х(н), процењује цену доласка од било ког датог чвора н до одредишног чвора.

Главна идеја А* је да процени сваки чвор на основу два параметра:

архитектура пролећне чизме

г(н):стварни трошак доласка од почетног чвора до чвора н. Представља збир трошкова одлазних ивица чвора н.х Н):Хеуристички трошак (такође познат као 'цена процене') од чвора н до одредишног чвора н. Ова хеуристичка функција специфична за проблем мора бити прихватљива, што значи да никада не прецењује стварну цену постизања циља. Функција евалуације чвора н је дефинисана као ф(н) = г(н) х(н).

Алгоритам А* бира чворове које треба истражити на основу најниже вредности ф(н), преферирајући чворове са најнижим процењеним укупним трошковима да би се постигао циљ. А* алгоритам ради:

1. Направите отворену листу пронађених, али неистражених чворова.
2. Направите затворену листу за држање већ истражених чворова.
3. Додајте почетни чвор на отворену листу са почетном вредношћу г
4. Понављајте следеће кораке док отворена листа не буде празна или док не дођете до циљног чвора:
   1. Пронађите чвор са најмањом ф-вредношћу (тј. чвор са мањим г(н) х(н)) у отвореној листи.
   2. Преместите изабрани чвор са отворене листе на затворену листу.
   3. Креирајте све важеће потомке изабраног чвора.
   4. За сваког наследника израчунајте његову г-вредност као збир г вредности тренутног чвора и цене преласка са тренутног чвора на чвор наследник. Ажурирајте г-вредност трагача када се пронађе боља путања.
   5. Ако следбеник није на отвореној листи, додајте га са израчунатом г-вредношћу и израчунајте његову х-вредност. Ако је већ на отвореној листи, ажурирајте његову г вредност ако је нова путања боља.
   6. Поновите циклус. Алгоритам А* се завршава када се достигне циљни чвор или када се отворена листа испразни, указујући да нема путања од почетног чвора до циљног чвора. Алгоритам за претрагу А* се широко користи у различитим областима као што су роботика, видео игре, мрежно рутирање и проблеми у дизајну јер је ефикасан и може да пронађе оптималне путање у графовима или мрежама.

Међутим, избор одговарајуће и прихватљиве хеуристичке функције је од суштинског значаја како би алгоритам радио исправно и обезбедио оптимално решење.

Историја алгоритма за претрагу А* у вештачкој интелигенцији

Развили су га Петер Харт, Нилс Нилссон и Бертрам Рапхаел на Стенфордском истраживачком институту (сада СРИ Интернатионал) као проширење Дијкстриног алгоритма и других алгоритама претраживања тог времена. А* је први пут објављен 1968. и брзо је стекао признање због свог значаја и ефикасности у заједницама вештачке интелигенције и рачунарских наука. Ево кратког прегледа најкритичнијих прекретница у историји алгоритма претраге А*:

Рани алгоритми претраге:Пре развоја А*, постојали су различити алгоритми за претрагу графова, укључујући претрагу у дубину (ДФС) и претрагу у ширину (БФС). Иако су ови алгоритми помогли у проналажењу путања, нису гарантовали оптималност нити су узели у обзир хеуристику која би водила претрагуДијкстрин алгоритам:Године 1959. холандски компјутерски научник Едсгер В. Дијкстра увео је Дијкстрин алгоритам, који је пронашао најкраћу путању у пондерисаном графу са ненегативним тежинама ивица. Дијкстрин алгоритам је био ефикасан, али је због своје исцрпности имао ограничења када се користи на већим графовима илиИнформисана претрага:Алгоритми претраживања засновани на знању (такође познати као хеуристичка претрага) су развијени да инкорпорирају хеуристичке информације, као што су процењени трошкови, како би се процес претраживања ефикасно водио. Грееди Бест-Фирст Сеарцх је био један од таквих алгоритама, али није гарантовао оптималност за проналажење најкраћег пута.А* развој:Године 1968. Питер Харт, Нилс Нилссон и Бертрам Рафаел су представили А* алгоритам као комбинацију Дијкстриног алгоритма и Похлепне прве претраге. А* је користио хеуристичку функцију да процени цену од тренутног чвора до одредишног чвора комбинујући је са стварним трошковима достизања тренутног чвора. Ово је омогућило А* да свесније истражује граф, избегавајући непотребне путање и гарантујући оптимално решење.Праведност и савршенство:Аутори А* су показали да је алгоритам савршен (увек нађе решење ако оно постоји) и оптималан (пронађе најкраћи пут) под одређеним условима.Широко распрострањено усвајање и напредак:А* је брзо стекао популарност у АИ и ИТ заједницама због своје ефикасности, а истраживачи и програмери су проширили и применили А* алгоритам на различита поља, укључујући роботику, видео игре, инжењеринг и мрежно рутирање. Неколико варијација и оптимизација А* алгоритма је предложено током година, као што су Инкрементални А* и Паралелни А*. Данас је А* алгоритам за претрагу и даље фундаменталан и широко коришћен алгоритам у вештачкој интелигенцији и обиласку графова. И даље игра кључну улогу у различитим апликацијама и истраживачким пољима. Његов утицај на вештачку интелигенцију и допринос проналажењу путање и проблемима оптимизације учинили су га алгоритмом темељцем у истраживању интелигентних система.

Како функционише А* алгоритам за претрагу у вештачкој интелигенцији?

Алгоритам за претрагу А* (изговара се 'слово А') је популаран и широко коришћен алгоритам за обилажење графова у вештачкој интелигенцији и рачунарству. Користи се за проналажење најкраћег пута од почетног чвора до одредишног чвора у пондерисаном графу. А* је информисани алгоритам претраживања који користи хеуристику да ефикасно води претрагу. Алгоритам претраге А* ради на следећи начин:

Алгоритам почиње са приоритетним редом за чување чворова које треба истражити. Такође инстанцира две структуре података г(н): Цена најкраће путање до сада од почетног чвора до чвора н и х(н), процењена цена (хеуристичка) од чвора н до одредишног чвора. Често је разумна хеуристика, што значи да никада не прецењује стварну цену постизања циља. Ставите почетни чвор у приоритетни ред и поставите његов г(н) на 0. Ако приоритетни ред није празан, Уклоните чвор са најнижим ф(н) из реда приоритета. ф(н) = г(н) х(н). Ако је избрисани чвор одредишни чвор, алгоритам се завршава и путања је пронађена. У супротном, проширите чвор и креирајте његове суседе. За сваки суседни чвор израчунајте његову почетну г(н) вредност, која је збир г вредности тренутног чвора и цене преласка са тренутног чвора на суседни чвор. Ако суседни чвор није у приоритетном редоследу или је оригинална г(н) вредност мања од његове тренутне г вредности, ажурирајте његову г вредност и поставите његов родитељски чвор на тренутни чвор. Израчунајте вредност ф(н) из суседног чвора и додајте је у приоритетни ред.

Ако се циклус заврши без проналажења одредишног чвора, граф нема путању од почетка до краја. Кључ ефикасности А* је његова употреба хеуристичке функције х(н) која даје процену преосталих трошкова достизања циља било ког чвора. Комбиновањем стварних трошкова г (н) са хеуристичким трошковима х (н), алгоритам ефикасно истражује обећавајуће путање, дајући приоритет чворовима који ће вероватно довести до најкраћег пута. Важно је напоменути да ефикасност А* алгоритма у великој мери зависи од избора хеуристичке функције. Прихватљиве хеуристике обезбеђују да алгоритам увек пронађе најкраћи пут, али боље информисана и тачнија хеуристика може довести до брже конвергенције и смањеног простора за претрагу.

Предности А* алгоритма за претрагу у вештачкој интелигенцији

Алгоритам за претрагу А* нуди неколико предности у сценаријима вештачке интелигенције и решавања проблема:

Оптимално решење:А* обезбеђује проналажење оптималног (најкраћег) пута од почетног чвора до одредишног чвора у пондерисаном графу са прихватљивом хеуристичком функцијом. Ова оптималност је одлучујућа предност у многим апликацијама где је од суштинског значаја проналажење најкраћег пута.Комплетност:Ако решење постоји, А* ће га пронаћи, под условом да граф нема бесконачну цену. Ово својство потпуности обезбеђује да А* може да искористи решење ако оно постоји.Ефикасност:А* је ефикасан ако се користи ефикасна и прихватљива хеуристичка функција. Хеуристика води претрагу до циља фокусирајући се на обећавајуће путање и избегавајући непотребно истраживање, чинећи А* ефикаснијим од несвесних алгоритама претраживања као што је претрага у ширину или претрага у дубину.Свестраност:А* је широко применљив на различите области проблема, укључујући проналажење пута, планирање руте, роботику, развој игара и још много тога. А* се може користити за ефикасно проналажење оптималних решења све док се може дефинисати смислена хеуристика.Оптимизована претрага:А* одржава редослед приоритета да изабере чворове са мањом вредношћу ф(н) (г(н) и х(н)) за проширење. Ово му омогућава да прво истражи путеве који обећавају, што смањује простор за претрагу и доводи до брже конвергенције.Ефикасност меморије:За разлику од неких других алгоритама за претрагу, као што је претрага у ширину, А* складишти само ограничен број чворова у приоритетном реду, што га чини ефикасним у меморији, посебно за велике графове.Хеуристика која се може подесити:Перформансе А* могу се фино подесити избором различитих хеуристичких функција. Више образоване хеуристике могу довести до брже конвергенције и мање проширених чворова.Опсежно истражено:А* је добро успостављен алгоритам са деценијама истраживања и практичних примена. Развијене су многе оптимизације и варијације, што га чини поузданим и добро разумљивим алатом за решавање проблема.Веб претрага:А* се може користити за веб-базирану претрагу путања, где алгоритам стално ажурира путању у складу са променама у окружењу или појавом нових Омогућава доношење одлука у реалном времену у динамичким сценаријима.

Недостаци А* алгоритма за претрагу у вештачкој интелигенцији

Иако је алгоритам за претрагу А* (слово А) широко коришћена и моћна техника за решавање проблема АИ проналажења путање и преласка графова, он има недостатке и ограничења. Ево неких од главних недостатака алгоритма за претрагу:

Хеуристичка тачност:Перформансе А* алгоритма у великој мери зависе од тачности хеуристичке функције која се користи за процену трошкова од тренутног чвора до Ако је хеуристика неприхватљива (никада не прецењује стварни трошак) или недоследна (задовољава неједнакост троугла), А* можда неће пронаћи оптималну путању или може истражити више чворова него што је потребно, што утиче на његову ефикасност и тачност.Употреба меморије:А* захтева да се сви посећени чворови чувају у меморији ради праћења истражених путања. Коришћење меморије понекад може да постане значајан проблем, посебно када се ради са великим простором за претрагу или ограниченим меморијским ресурсима.Временска сложеност:Иако је А* генерално ефикасан, његова временска сложеност може бити разлог за забринутост за огромне просторе за претрагу или графиконе. У најгорем случају, А* може потрајати експоненцијално дуже да пронађе оптималну путању ако је хеуристика неприкладна за проблем.Уско грло на одредишту:У специфичним сценаријима, А* алгоритам треба да истражи чворове далеко од одредишта пре него што коначно стигне до одредишног региона. Овај проблем се јавља када хеуристика треба да ефикасно усмери претрагу ка циљу.Везивање трошкова:А* се суочава са потешкоћама када више чворова има исту ф-вредност (збир стварних и хеуристичких трошкова). Коришћена стратегија може утицати на оптималност и ефикасност откривеног пута. Ако се не поступа правилно, то може довести до истраживања непотребних чворова и успорити алгоритам.Сложеност у динамичном окружењу:У динамичким окружењима где се цена ивица или чворова може променити током претраге, А* можда није погодан јер се не прилагођава добро таквим променама. Реформулација од нуле може бити рачунски скупа, а Д* (Динамички А*) алгоритми су дизајнирани да реше овоСавршенство у бесконачном простору:А* можда неће наћи решење у бесконачном простору стања. У таквим случајевима, може да ради неограничено, истражујући све већи број чворова без проналажења решења. Упркос овим недостацима, А* је и даље робустан и широко коришћен алгоритам јер може ефикасно да пронађе оптималне путање у многим практичним ситуацијама ако је хеуристичка функција добро дизајнирана и простором за претрагу се може управљати. Предложене су различите варијације и варијанте А* да би се ублажила нека од његових ограничења.

Примене А* алгоритма за претрагу у вештачкој интелигенцији

Алгоритам претраживања А* (слово А) је широко коришћен и робустан алгоритам за проналажење путање у вештачкој интелигенцији и рачунарству. Његова ефикасност и оптималност чине га погодним за различите примене. Ево неких типичних примена А* алгоритма претраге у вештачкој интелигенцији:

Проналажење пута у играма:А* се често користи у видео играма за кретање ликова, непријатељску АИ навигацију и проналажење најкраћег пута од једне локације до друге на мапи игре. Његова способност да пронађе оптималну путању на основу трошкова и хеуристике чини га идеалним за апликације у реалном времену као што су игре.Роботика и аутономна возила:А* се користи у роботици и аутономној навигацији возила за планирање неоптималне руте за роботе да стигну до одредишта, избегавајући препреке и узимајући у обзир трошкове терена. Ово је кључно за ефикасно и безбедно кретање у природном окружењу.Решавање лавиринта:А* може ефикасно да пронађе најкраћи пут кроз лавиринт, што га чини вредним у многим апликацијама за решавање лавиринта, као што је решавање загонетки или навигација по сложеним структурама.Планирање руте и навигација:У ГПС системима и апликацијама за мапирање, А* се може користити за проналажење оптималне руте између две тачке на мапи, узимајући у обзир факторе као што су растојање, услови саобраћаја и топологија путне мреже.Решавање загонетки:А* може да реши различите дијаграмске загонетке, као што су клизне загонетке, судоку и проблем са 8 загонетки. Алокација ресурса: У сценаријима где ресурси морају бити оптимално алоцирани, А* може помоћи у проналажењу најефикаснијег пута алокације, минимизирајући трошкове и максимизирајући ефикасност.Мрежно рутирање:А* се може користити у рачунарским мрежама за проналажење најефикасније руте за пакете података од извора до одредишног чвора.Обрада природног језика (НЛП):У неким НЛП задацима, А* може да генерише кохерентне и контекстуалне одговоре тражећи могуће секвенце речи на основу њихове вероватноће и релевантности.Планирање пута у роботици:А* се може користити за планирање путање робота од једне тачке до друге, узимајући у обзир различита ограничења, као што је избегавање препрека или минимизирање потрошње енергије.АИ игре:А* се такође користи за доношење интелигентних одлука за ликове који нису играчи (НПЦ), као што је одређивање најбољег начина за постизање циља или координацију покрета у тимској игри.

Ово је само неколико примера како алгоритам А* претраге проналази примену у различитим областима вештачке интелигенције. Његова флексибилност, ефикасност и оптимизација чине га вредним алатом за многе проблеме.

Ц програм за А* алгоритам претраживања у вештачкој интелигенцији

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

Ц++ програм за А* алгоритам претраге у вештачкој интелигенцији

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

Објашњење:

инстанца у јава

Чвор структуре:Ово дефинише структуру чвора која представља ћелију мреже. Садржи к и и координате чвора, цену г од почетног чвора до тог чвора, хеуристичку вредност х (процењена цена од тог чвора до одредишног чвора) и показивач на
1. почетни чвор путање.
Израчунај хеуристички:Ова функција израчунава хеуристику користећи еуклидско растојање између чвора и циља АСтарСеарцх: Ова функција покреће А* алгоритам претраге. Узима почетну и одредишну координате, мрежу и враћа вектор парова који представљају координате најкраће путање од почетка до краја.Примарна:Главна функција програма преузима од корисника улазне мреже, исходиште и координате циља. Затим позива АСтарСеарцх да пронађе најкраћи пут и штампа резултат. Чвор структуре: Ово дефинише структуру чвора која представља ћелију мреже. Садржи координате к и и чвора, цену г од почетног чвора до тог чвора, хеуристичку вредност х (процењена цена од тог чвора до одредишног чвора) и показивач на почетни чвор путање.Израчунај хеуристички:Ова функција израчунава хеуристику користећи еуклидско растојање између чвора и циља АСтарСеарцх: Ова функција покреће А* алгоритам претраге. Узима почетну и одредишну координате, мрежу и враћа вектор парова који представљају координате најкраће путање од почетка до краја.

Сампле Оутпут

 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 

Јава програм за А* алгоритам претраживања у вештачкој интелигенцији

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

А* Сложеност алгоритма претраживања у вештачкој интелигенцији

Алгоритам за претрагу А* (изговара се 'А-звезда') је популаран и широко коришћен алгоритам за обилажење графова и тражење путање у вештачкој интелигенцији. Проналажење најкраће путање између два чвора у окружењу заснованом на графу или мрежи је обично уобичајено. Алгоритам комбинује Дијкстрине и похлепне елементе претраге за најбоље-прво да би истражио простор за претрагу док ефикасно обезбеђује оптималност. Неколико фактора одређује сложеност А* алгоритма претраге. Величина графа (чворови и ивице): Број чворова и ивица графа у великој мери утиче на сложеност алгоритма. Више чворова и ивица значи више могућих опција за истраживање, што може повећати време извршења алгоритма.

Хеуристичка функција: А* користи хеуристичку функцију (често се означава као х(н)) за процену трошкова од тренутног чвора до одредишног чвора. Прецизност ове хеуристике у великој мери утиче на ефикасност А* претраге. Добра хеуристика може помоћи бржем усмеравању претраге до циља, док лоша хеуристика може довести до непотребног претраживања.

Структуре података:А* одржава две структуре главних података: отворену листу (приоритетни ред) и затворену листу (или посећени скуп). Ефикасност ових структура података, заједно са изабраном имплементацијом (нпр. бинарне гомиле приоритетног реда), утиче на перформансе алгоритма.Фактор гране:Просечан број пратилаца за сваки чвор утиче на број проширених чворова током претраге. Већи фактор гранања може довести до више истраживања, која се повећавајуОптималност и комплетност:А* гарантује и оптималност (проналажење најкраћег пута) и потпуност (проналажење решења које постоји). Међутим, ова гаранција долази са компромисом у смислу рачунске сложености, пошто алгоритам мора истражити различите путеве за оптималне перформансе. Што се тиче временске сложености, изабрана хеуристичка функција утиче на А* у најгорем случају. Са прихваћеном хеуристиком (која никада не прецењује стварну цену постизања циља), А* проширује најмање чворова међу алгоритмима оптимизације. Временска сложеност А* у најгорем случају је експоненцијална у најгорем случају О(б ^ д), где је 'б' ефективни фактор гранања (просечан број пратилаца по чвору) и 'д' је оптималан

У пракси, међутим, А* често ради знатно боље због утицаја хеуристичке функције која помаже да алгоритам води ка обећавајућим путањама. У случају добро осмишљене хеуристике, ефективни фактор гранања је много мањи, што доводи до бржег приступа оптималном решењу.