Search Algorithms in AI
Search Algorithms in AI
Search Algorithms in AI
Arti cial Intelligence is the study of building agents that act rationally. Most of the time,
these agents perform some kind of search algorithm in the background in order to
achieve their tasks.
The Solution to a search problem is a sequence of actions, called the plan that
transforms the start state to the goal state.
This plan is achieved through search algorithms.
There are far too many powerful search algorithms out there to t in a single article.
Instead, this article will discuss six of the fundamental search algorithms, divided into
two categories, as shown below.
The search algorithms in this section have no additional information on the goal node
other than the one provided in the problem de nition. The plans to reach the goal state
from the start state di er only by the order and/or length of actions. Uninformed search
is also called Blind search.
A problem graph, containing the start node S and the goal node G.
A strategy, describing the manner in which the graph will be traversed to get to G .
A fringe, which is a data structure used to store all the possible states (nodes) that you
can go from the current states.
A tree, that results while traversing to the goal node.
A solution plan, which the sequence of nodes from S to G.
Depth- rst search (DFS) is an algorithm for traversing or searching tree or graph data
structures. The algorithm starts at the root node (selecting some arbitrary node as the
root node in the case of a graph) and explores as far as possible along each branch before
backtracking.
Example:
Question. Which solution would DFS nd to move from node S to node G if run on the
graph below?
Solution. The equivalent search tree for the above graph is as follows. As DFS traverses
the tree “deepest node rst”, it would always pick the deeper branch until it reaches the
solution (or it runs out of nodes, and goes to the next branch). The traversal is shown in
blue arrows.
Let = the depth of the search tree = number of levels of the search tree.
Breadth- rst search (BFS) is an algorithm for traversing or searching tree or graph data
structures. It starts at the tree root (or some arbitrary node of a graph, sometimes
referred to as a ‘search key’), and explores all of the neighbor nodes at the present depth
prior to moving on to the nodes at the next depth level.
Example:
Question. Which solution would BFS nd to move from node S to node G if run on the
graph below?
Solution. The equivalent search tree for the above graph is as follows. As BFS traverses
the tree “shallowest node rst”, it would always pick the shallower branch until it
reaches the solution (or it runs out of nodes, and goes to the next branch). The traversal is
shown in blue arrows.
Path: S -> D -> G
Time complexity: Equivalent to the number of nodes traversed in BFS until the
shallowest solution.
UCS is di erent from BFS and DFS because here the costs come into play. In other words,
traversing via di erent edges might not have the same cost. The goal is to nd a path
where the cumulative sum of costs is least.
cost(root) = 0
Example:
Question. Which solution would UCS nd to move from node S to node G if run on the
graph below?
Solution. The equivalent search tree for the above graph is as follows. Cost of each node is
the cumulative cost of reaching that node from the root. Based on UCS strategy, the path
with least cumulative cost is chosen. Note that due to the many options in the fringe, the
algorithm explores most of them so long as their cost is low, and discards them when a
lower cost path is found; these discarded traversals are not shown below. The actual
traversal is shown in blue.
Path: S -> A -> B -> G
Cost: 5
Time complexity:
Space complexity:
Advantages:
UCS is complete.
UCS is optimal.
Disadvantages:
Here, the algorithms have information on the goal state, which helps in more e cient
searching. This information is obtained by something called a heuristic.
In this section, we will discuss the following search algorithms.
1. Greedy Search
2. A* Tree Search
3. A* Graph Search
Greedy Search
In greedy search, we expand the node closest to the goal node. The “closeness” is
estimated by a heuristic h(x) .
Strategy: Expand the node closest to the goal state, i.e. expand the node with lower h
value.
Example:
Question. Find the path from S to G using greedy search. The heuristic values h of each
node below the name of the node.
Solution. Starting from S, we can traverse to A(h=9) or D(h=5). We choose D, as it has the
lower heuristic cost. Now from D, we can move to B(h=4) or E(h=3). We choose E with lower
heuristic cost. Finally, from E, we go to G(h=0). This entire traversal is shown in the search
tree below, in blue.
Path: S -> D -> E -> G
Advantage: Works well with informed search problems, with fewer steps to reach a goal.
Disadvantage: Can turn into unguided DFS in the worst case.
A* Tree Search
Here, h(x) is called the forward cost, and is an estimate of the distance of the current
node from the goal node.
And, g(x) is called the backward cost, and is the cumulative cost of a node from the
root node.
A* search is optimal only when for all nodes, the forward cost for a node h(x)
underestimates the actual cost h*(x) to reach the goal. This property of A* heuristic is
called admissibility.
Admissibility:
Strategy: Choose the node with lowest f(x) value.
Example:
Solution. Starting from S, the algorithm computes g(x) + h(x) for all nodes in the fringe at
each step, choosing the node with the lowest sum. The entire working is shown in the
table below.
Note that in the fourth set of iteration, we get two paths with equal summed cost f(x), so
we expand them both in the next set. The path with lower cost on further expansion is the
chosen path.
Path h(x) g(x) f(x)
S 7 0 7
S -> A 9 3 12
S -> D ✔ 5 2 7
S -> D -> B -> C -> G 0 5+4=99
Cost: 7
A* Graph Search
A* tree search works well, except that it takes time re-exploring the branches it has
already explored. In other words, if the same node has expanded twice in di erent
branches of the search tree, A* search might explore both of those branches, thus
wasting time
A* Graph Search, or simply Graph Search, removes this limitation by adding this rule:
do not expand the same node more than once.
Heuristic. Graph search is optimal only when the forward cost between two successive
nodes A and B, given by h(A) - h (B) , is less than or equal to the backward cost between
those two nodes g(A -> B). This property of graph search heuristic is called
consistency.
Consistency:
Example
Solution. We solve this question pretty much the same way we solved last question, but in
this case, we keep a track of nodes explored so that we don’t re-explore them.
Path: S -> D -> B -> C -> E -> G
Cost: 7
References
MdRa Akhtar
Check out this Author's contributed articles.
If you like GeeksforGeeks and would like to contribute, you can also write an article using
contribute.geeksforgeeks.org or mail your article to [email protected]. See
your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you nd anything incorrect by clicking on the "Improve
Article" button below.
Article Tags : Machine Learning Technical Scripter Artificial Intelligence Technical Scripter 2018
COMPANY LEARN
About Us Algorithms
Careers Data Structures
Privacy Policy Languages
Contact Us CS Subjects
Video Tutorials
PRACTICE CONTRIBUTE
Company-wise Write an Article
Topic-wise GBlog
Contests Videos
Subjective Questions