A* Algorithm
Tabish, CSE-09/16
Department of Computer Science & Engineering, NIT Srinagar
Introduction to the Algorithm:
Motivation
To approximate the shortest path in real-life situations, like- in maps, games where there can be many hindrances.
A* Search algorithm is one of the best and popular technique used in path-finding and graph traversals. 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).
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 don’t know the actual distance until we find the path,
because all sorts of things can be in the way (walls, water, etc.).
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
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)
Code:
class Node():
def __init__(self, parent=None, position=None):
[Link] = parent
[Link] = position
self.g, self.h, self.f = 0,0,0
def __eq__(self, other):
return [Link] == [Link]
def astar(maze, start, end):
start_node = Node(None, start)
start_node.g = start_node.h = start_node.f = 0
end_node = Node(None, end)
end_node.g = end_node.h = end_node.f = 0
open_list = []
closed_list = []
open_list.append(start_node)
while len(open_list) > 0:
current_node = open_list[0]
current_index = 0
for index, item in enumerate(open_list):
if item.f < current_node.f:
current_node = item
current_index = index
open_list.pop(current_index)
closed_list.append(current_node)
if current_node == end_node:
path = []
current = current_node
while current is not None:
[Link]([Link])
current = [Link]
return path[::-1] # Return reversed path
# Generate children
children = []
for new_position in [(0, -1), (0, 1), (-1, 0), (1, 0), (-1, -1), (-1, 1), (1, -1),
(1, 1)]: # Adjacent squares
node_position = (current_node.position[0] + new_position[0],
current_node.position[1] + new_position[1])
# Make sure within range
if node_position[0] > (len(maze) - 1) or node_position[0] < 0 or
node_position[1] > (len(maze[len(maze)-1]) -1) or node_position[1] < 0:
continue
if maze[node_position[0]][node_position[1]] != 0:
continue
# Create new node
new_node = Node(current_node, node_position)
# Append
[Link](new_node)
# Loop through children
for child in children:
# Child is on the closed list
for closed_child in closed_list:
if child == closed_child:
continue
# Create the f, g, and h values
child.g = current_node.g + 1
child.h = (([Link][0] - end_node.position[0]) ** 2) +
(([Link][1] - end_node.position[1]) ** 2)
child.f = child.g + child.h
# Child is already in the open list
for open_node in open_list:
if child == open_node and child.g > open_node.g:
continue
# Add the child to the open list
open_list.append(child)
def main():
maze = [[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
start = (0, 0)
end = (7, 6)
path = astar(maze, start, end)
print(path)
if __name__ == '__main__':
main()
Output Observed for differen t In puts :
Input passed:
start = (0, 0)
end = (7, 6)
maze = [[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
Output Obtained:
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 3), (5, 4), (6, 5), (7, 6)]
Input passed:
start = (3, 4)
end = (8, 5)
maze = [[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 1, 0, 1, 0, 0, 0],
[0, 0, 1, 0, 1, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0]]
Output Obtained:
[(3, 4), (4, 3), (5, 3), (6, 3), (7, 3), (8, 3), (9, 4), (8, 5)]
