Artificial Intelligence

Lecture Notes - 3
(Subject Code: CSC 602, ITC 651)

Prepared by
Dr. Sourabh Jain
Indian Institute of Information Technology Sonepat
 Uninformed Search Algorithms
 Whoever it may be (humans or AI) need to think of all possible ways to reach the
goal state(if it exists) from the initial state, all the consequences, etc. Similarly, AI
systems use various search algorithms for a particular goal state(if it exists).

 As the name ‘Uninformed Search’ means the machine blindly follows the
algorithm regardless of whether right or wrong, efficient or in-efficient.

 Uninformed search is a class of general-purpose search algorithms which

operates in brute force-way. Uninformed search algorithms do not have
additional information about state or search space other than how to traverse the
tree or visit the nodes in the tree , so it is also called blind search.
 Types of Uninformed Search Algorithms
The various types of uninformed search algorithms are as follows:

 Breadth-first Search

 Depth-first Search

 Uniform cost search

 Breadth-First Search
 Breadth-first search is the most common search strategy for traversing a tree or
graph. This algorithm searches breadthwise in a tree or graph, so it is called
breadth-first search.

 BFS algorithm starts searching from the root node of the tree and expands all
successor node at the current level before moving to nodes of next level.

 The breadth-first search algorithm is an example of a general-graph search

algorithm.

 Breadth-first search implemented using FIFO queue data structure.

 Method to Implement Breadth-First Search
• Declare a queue and insert the starting vertex.
• Initialize a visited array and mark the starting vertex as
visited.
• Follow the below process till the queue becomes empty:
 Remove the first vertex of the queue.
 Mark that vertex as visited.
 Insert all the unvisited neighbors of the vertex into the
queue.
 Breadth-First Search Example
The below tree structure shown the traversing of the tree using BFS algorithm from
the root node S to goal node K.
 Breadth-First Search (Cont…)
Advantages:

 BFS will provide a solution if any solution exists.

 If there are more than one solutions for a given problem, then BFS will provide
the minimal solution which requires the least number of steps.

Disadvantages:

 It requires lots of memory since each level of the tree must be saved into memory
to expand the next level.

 BFS needs lots of time if the solution is far away from the root node.
 Breadth-First Search (Cont…)
Time Complexity: Time Complexity of BFS algorithm can be obtained by the number of
nodes traversed in BFS until the shallowest Node. Where the d= depth of shallowest
solution and b is a node at every state.

T (b) = 1+b2+b3+.......+ bd= O (bd)

Space Complexity: Space complexity of BFS algorithm is given by the Memory size of
frontier which is O (bd) .

Completeness: BFS is complete, which means if the shallowest goal node is at some finite
depth, then BFS will find a solution.

Optimality: BFS is optimal if path cost is a non-decreasing function of the depth of the
node.
 Depth-First Search
 Depth-first search is a recursive algorithm for traversing a tree or graph data
structure.

 The process of the DFS algorithm is similar to the BFS algorithm.

 It is called the depth-first search because it starts from the root node and follows
each path to its greatest depth node before moving to the next path.

 It will be traversing, searching for a key at the leaf of a particular branch. If the
key is not found the searching retraces its steps back to the point from where the
other branch was left unexplored and the same procedure is repeated for that
other branch.

 DFS is implemented using LIFO Stack data structure

 Depth-First Search (Cont…)
The below search tree shown the flow of depth-first search, and it will follow the order as:

Root node--->Left node ----> right node

It will start searching from root node S,

and traverse A, then B, then D and E,
after traversing E, it will backtrack the
tree as E has no other successor and
still goal node is not found. After
backtracking it will traverse node C and
then G, and here it will terminate as it
found goal node.
 Depth-First Search (Cont…)
Advantages:

 DFS requires very less memory as it only needs to store a stack of the nodes on
the path from root node to the current node.

 It takes less time to reach to the goal node than BFS algorithm (if it traverses in
the right path).

Disadvantages:

 There is the possibility that many states keep re-occurring, and there is no
guarantee of finding the solution.

 DFS algorithm goes for deep down searching and sometime it may go to the
infinite loop.
 Depth-First Search (Cont…)
Completeness: DFS search algorithm is complete within finite state space as it will expand
every node within a limited search tree.

Time Complexity: Time complexity of DFS will be equivalent to the node traversed by the
algorithm. It is given by:

T(n)= 1+ n2+ n3 +.........+ nm=O(nm)

Where, m= maximum depth of any node and this can be much larger than d (Shallowest
solution depth)

Space Complexity: DFS algorithm needs to store only single path from the root node,
hence space complexity of DFS is equivalent to the size of the fringe set, which is O(bm).

Optimal: DFS search algorithm is non-optimal, as it may generate a large number of steps
or high cost to reach to the goal node.
 Uniform-cost Search Algorithm
 Uniform-cost search is a searching algorithm used for traversing a weighted tree
or graph.

 This algorithm comes into play when a different cost is available for each edge.

 The primary goal of the uniform-cost search is to find a path to the goal node
which has the lowest cumulative cost. Uniform-cost search expands nodes
according to their path costs form the root node.

 It can be used to solve any graph/tree where the optimal cost is in demand.

 A uniform-cost search algorithm is implemented by the priority queue. It gives

maximum priority to the lowest cumulative cost. Uniform cost search is equivalent
to BFS algorithm if the path cost of all edges is the same.
 Uniform-cost Search Algorithm (Cont…)
The below search tree shown the flow of unform-cost search, and it will follow the order as:
 Uniform-cost Search Algorithm (Cont…)
In the figure consider S to be the start node
and G to be the goal state.

There are the following two paths from Node

S to G.

Path 1: S---> A--- >C--- > D--- > G

Total Cost: 6

Path 2: S--- > G

Total Cost 12

If we have traversed through Path 1 definitely

our total path cost from S to G is just 6.

Note: But this may not work with all cases.

 Uniform-cost Search Algorithm Examples:
Example 1: Example 2:
 Uniform-cost Search Algorithm (Cont…)
Advantage:

Uniform cost search is optimal because at every state the path with the least cost is
chosen.

Disadvantage:

It does not care about the number of steps involve in searching and only concerned
about path cost. Due to which this algorithm may be stuck in an infinite loop.
 Uniform-cost Search Algorithm (Cont…)
Completeness: Uniform-cost search is complete, such as if there is a solution, UCS will
find it.

Time Complexity:

Let C* is Cost of the optimal solution, and ε is each step to get closer to the goal node. Then
the number of steps is = C*/ε+1. Here we have taken +1, as we start from state 0 and end to
C*/ε.

Hence, the worst-case time complexity of Uniform-cost search is O(b1 + [C*/ε]) .

Space Complexity:

The same logic is for space complexity so, the worst-case space complexity of Uniform-cost

search is O(b1 + [C*/ε]).

Optimal: Uniform-cost search is always optimal as it only selects a path with the lowest
path cost.