Scribd
Upload
134 views

A Algorithm

A* Search Algorithm is used to find the shortest path between a starting node and ending node. It uses two values, g(cost from start to current) and h(estimated cost from current to end), to calculate f(cost) = g + h. At each step, it expands the unexplored node with the lowest f first. This makes it an informed search. It is commonly used in pathfinding in games and maps. The time complexity is O(E) where E is the number of edges, as in worst case the algorithm may need to explore all edges to find the shortest path.

Uploaded by

Sachin Sharma
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
134 views

A Algorithm

A* Search Algorithm is used to find the shortest path between a starting node and ending node. It uses two values, g(cost from start to current) and h(estimated cost from current to end), to calculate f(cost) = g + h. At each step, it expands the unexplored node with the lowest f first. This makes it an informed search. It is commonly used in pathfinding in games and maps. The time complexity is O(E) where E is the number of edges, as in worst case the algorithm may need to explore all edges to find the shortest path.

Uploaded by

Sachin Sharma
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

A* Search Algorithm

Motivation
To approximate the shortest path in real-life situations, like- in maps, games where there can be many
hindrances.
We can consider a 2D Grid having several obstacles and we start from a source cell (coloured green below)
to reach towards a goal cell (coloured red below)

What is A* Search Algorithm?


A* Search algorithm is one of the best and popular technique used in path-finding and graph traversals.
Why A* Search Algorithm ?
Informally speaking, A* Search algorithms, unlike other traversal techniques, it has brains. What it means
is that it is really a smart algorithm which separates it from the other conventional algorithms. This fact is
cleared in detail in below sections.
And it is also worth mentioning that many games and web-based maps use this algorithm to find the shortest
path very efficiently (approximation).
Explanation
Consider a square grid having many obstacles and we are given a starting cell and a target cell. We want
to reach the target cell (if possible) from the starting cell as quickly as possible. Here A* Search Algorithm
comes to the rescue.
What A* Search Algorithm does is that at each step it picks the node according to a value-f which is a
parameter equal to the sum of two other parameters g and h. At each step it picks the node/cell having
the lowest f, and process that node/cell.
We define g and h as simply as possible below
g = the movement cost to move from the starting point to a given square on the grid, following the path
generated to get there.
h = the estimated movement cost to move from that given square on the grid to the final destination. This
is often referred to as the heuristic, which is nothing but a kind of smart guess. We really dont know the
actual distance until we find the path, because all sorts of things can be in the way (walls, water, etc.).
There can be many ways to calculate this h which are discussed in the later sections.
Algorithm
We create two lists Open List and Closed List (just like Dijkstra Algorithm)
// A* Search Algorithm
1. Initialize the open list

2. Initialize the closed list


put the starting node on the open

list (you can leave its f at zero)

3. while the open list is not empty


a) find the node with the least f on
the open list, call it "q"

b) pop q off the open list

c) generate q's 8 successors and set their


parents to q

d) for each successor


i) if successor is the goal, stop search
successor.g = q.g + distance between
successor and q
successor.h = distance from goal to
successor (This can be done using many
ways, we will discuss three heuristics-
Manhattan, Diagonal and Euclidean
Heuristics)

successor.f = successor.g + successor.h

ii) if a node with the same position as


successor is in the OPEN list which has a
lower f than successor, skip this successor

iii) if a node with the same position as


successor is in the CLOSED list which has
a lower f than successor, skip this successor
otherwise, add the node to the open list
end (for loop)

e) push q on the closed list


end (while loop)

So suppose as in the below figure if we want to reach the target cell from the source cell, then the A* Search
algorithm would follow path as shown below. Note that the below figure is made by considering Euclidean
Distance as a heuristics.
Limitations
Although being the best pathfinding algorithm around, A* Search Algorithm doesnt
produce the shortest path always, as it relies heavily on heuristics / approximations to
calculate h
Applications
This is the most interesting part of A* Search Algorithm. They are used in games! But
how?
Ever played Tower Defense Games ?
Tower defense is a type of strategy video game where the goal is to defend a players
territories or possessions by obstructing enemy attackers, usually achieved by placing
defensive structures on or along their path of attack.

Time Complexity
Considering a graph, it may take us to travel all the edge to reach the destination cell
from the source cell [For example, consider a graph where source and destination
nodes are connected by a series of edges, like 0(source) >1 > 2 > 3 (target)
So the worse case time complexity is O(E), where E is the number of edges in the graph

AO* Algorithm

1. Initialise the graph to start node


2. Traverse the graph following the current path accumulating nodes that have
not yet been expanded or solved
3. Pick any of these nodes and expand it and if it has no successors call this
value FUTILITY otherwise calculate only f' for each of the successors.
4. If f' is 0 then mark the node as SOLVED
5. Change the value of f' for the newly created node to reflect its successors by
back propagation.
6. Wherever possible use the most promising routes and if a node is marked
as SOLVED then mark the parent node as SOLVED.
7. If starting node is SOLVED or value greater than FUTILITY, stop, else repeat
from 2.

You might also like