Chapter Three

Searching and Planning

By: Teshome M.

1
 What is Problem
What is a Problem? It is a gap between the existing
scenario and the expected scenario (situation). A problem
exists when an individual becomes aware of the existence
of an obstacle which makes it difficult to achieve a
desired goal or objective. Problem-solving is commonly
known as the method to reach the desired goal or find a
solution to a given situation. Problem-solving refers to
artificial intelligence techniques, including various
techniques such as forming efficient algorithms, heuristics,
and performing root cause analysis to find desirable
solutions.
A number of problems are addressed in AI. Mainly there
are two types of problems:

2
Mainly there are two types of problems:
1. Problems with discrete environment: These problems
need limited number of actions to achieve a goal.
• Example: The problems like computing the area of a
square. These can be solved by using deterministic
procedure and success is guaranteed. However, in real
world, there are very few problems which can be
solved using straight-forward methods.
2. Problems with continuous environment: sometimes,
problems can be continuous duet to environmental
factors. For such problems, a number of actions are
required to get the solution. Most real world problems
are solved by searching for solution. Artificial Intelligence
is concerned with such type of problems.
3
 Cont..
• Problem-solving in Artificial Intelligence usually
refers to researching a solution to a problem by
performing logical algorithms, utilizing polynomial
and differential equations, and executing them
using modeling paradigms. There can be various
solutions to a single problem, which are achieved
by different heuristics. Also, some problems have
unique solutions. It all rests on the nature of the
given problem.

4
 Problem Solving:
• Deals with finding a solution for a given problem. This
is done by finding an ordered sequence of operators
that transform the current state (initial state) into a
goal state. There are restrictions in problem solving,
which are expected to happen that deals with the
quality of the solution.
 Finding the shortest solution
 Finding the least expensive defining cost
 Finding any sequence as quickly as possible
Moreover, problems can be solved either in a general
problem solving approach or in a well-defined problem
solving approach.

5
 Well-defined problems and solutions
• A problem in general can be defined formally by
the following components. The initial state,
actions, and state transition implicitly define the
state space of the problem. If the problem is well-
defined then, it incorporates goal test and path
cost functions.

6
 Cont..
1. Initial State: the agents starting point (s).
2. Actions (Operators): A description of the possible actions
available to the agent given a particular state s, actions returns
the set of actions that can be executed in s.
3. Transition States: A description of what each action does.
The term successor generator can be used to refer to any state
reachable from a given state by a single action.
4. Goal Test: Determines whether a given state is a goal state.
Sometimes there is an explicit set of possible goal states, and
the test simply checks whether the given state is one of them.
5. Path Cost: is a sequence of states connected by a sequence
of actions.

7
 Cont..
• State Space of a problem incorporates the set of all
states reachable from the initial state by any
sequence of actions. The state space forms a
directed network or graph in which the nodes are
states and the links arc/curve between nodes are
actions.
• The Path cost function determines the cost of
sequence of states connected by a sequence of
edges (actions).
• Moreover, goal test function determines whether a
given state is a goal state. Sometimes there are
many possible set of goals indicated explicitly.
8
 Structure of state space
(Graph & Tree)
• To simplify search algorithms, it is convenient to represent a
problem in tree instead of a graph. Tree usually decreases
complexity of search at cost. There are duplicating nodes in
a graph linked more than one time. Tree is a graph in which
any two vertices are connected by exactly one path.
• N.B: Alternatively any graph with directed arrows/ no
cycle are a tree.
Tree:
– Hierarchical structure in a graphical form which has only
one path to a given node.
Graph:
– Non-hierarchical structure with several paths to a given
node.

9
Graph and Tree

10
 Steps in problem solving
1. Goal Formulation: This is a step that specifies exactly what
the goal based agent is trying to achieve. This step
narrows down the scope that the agent has to look at by
selecting certain states as goals from the rest of the set of
states in the problem definition.
2. Problem Formulation: Is a step that puts down the actions
and states that the agent has to consider given a goal by
avoiding any redundant states; such as, the initial state and the
allowable actions.
N.B: Problem formulation has a serious influence on the difficulty
of finding a solution for a problem. If you have a good problem
formulation then, it will be easy to find the solution. On the other
hand if the problem formulation is bad, finding the solution will be
difficult. Therefore, the quality of a goal (solution) highly depends
on the quality of problem formulation.
11
 Cont.
3. Search: This step deals with the process of looking
for the various sequences of actions that lead to a
goal state, evaluating them and choosing the optimal
sequence as much as possible. Searching is done on
the implicit sate of states so that reaching a goal is
very challenging or else on an explicit set of state
hence, searching will be easy.
4. Execute: Is the final step that the agent executes
and declares that, the chosen sequence of actions
leads to the solution and/or goal.

12
Common example of problem in Ai

13
 Example: Vacuum Cleaner World
• Problem definition for vacuum cleaner world
• States space: The state is determined by both the
agent location and the dirt locations. The agent is
in one of two locations, each of which might or
might not contain dirt. That means, the world
state space has only 2 positions, dirt or no dirt,
with 8 possible states. Possible actions are Move
Left (L), Move Right (R), or Suck the dirt (S). The
goal is to clear all the dirt from the rooms and the
path costs is one unit per action.

14
 Cont.
1. Initial state: Any state can be designated and taken as the
initial state.
2. Actions: In this simple environment, each state has just
three actions: Left, Right, and Suck. However, larger
environments can also include other actions such as move
Up and move Down in the state space.
3. Transition State: The actions have their expected effects,
except that moving Left in the leftmost square, moving
Right in the rightmost square, and sucking in a clean
square have no effect.
4. Goal Test: This checks whether all the rooms are clean or
not.
5. Path Cost: Each step costs a unit cost (1), so the path cost
is the number of steps in the path. Move right cost=>1,
Move Left cost=>1.

15
Clean House Task

16
 Cont..
• It is obvious that the world is too complex for a single
robot to observe what is in the environment and take
some sequences actions accordingly. To simplify the
complexity of the problem (rather than seen the full
version of the problem); let us assume that:
• The world has only two locations for the sake of
simplicity even though the world is so complex and
very challenging to come up with limited number of
states and actions.
• Each location may or may not contain dirt
• The agent may be in one location or the other,
• – Hence, there 8 possible world states and 3 possible
actions (Left, Right, Suck)

17
 Cont.
• Suck operator clean the dirt
• • Left and Right operators move the agent from
location to location. The agent cannot move
outside the rooms.
• • Goal: to clean up all the dirt in the rooms, if and
only if there is dirt in both or one of the rooms.
Otherwise, the agent will end up with failure if it
tries to clean a room which is already with no dirt.

18
Vacuum Cleaner state Space

19
 Cont.…
• The assumption is that the agent is in fully observable
world. The world is accessible to the agent, hence:
– It can determine its exact state through its sensors
– The agent’s sensor knows in which state it is currently
• Furthermore, the agent is in a deterministic
environment and knows exactly the effect of its actions.
Moreover, the calculate exactly which state it will be in
after any sequence of actions
• Action sequence is completely planned and known.
The agent is clear with what action to be taken.
Example - Vacuum cleaner world:
20
 Question
• What will happen if the agent is initially at [state =
5] and formulates action sequence [Right, Suck]?
Agent calculates and knows that it will get to a
goal state.
• If the agent moves Right then, it is on state {6}
• After taking the action Suck the dirt in state six, the
agent is finally on state {8}.
• N.B: If the environment is completely observable,
the vacuum cleaner always knows where it is and
where the dirt is. The solution then is reduced to
searching for a path from the initial state to the
goal state easily.
21
For example, consider the map of Romania
in the following figure below

22
 The problem formulation is therefore
• Initial state: at Arad
• Actions: with the successor function S:
• 🞑S(Arad) = {<AradZerind, Zerind>, <AradSibiu,
Sibiu>,<AradTimisoara, Timisoara}

• Goal test: at Bucharest

• Path cost: c(Arad, AradZerind, Zerind) = 75, c(Arad,
AradSibiu, Sibiu) = 140, c(Arad, Arad Timisoara,
Timisoara) = 118, etc.

23
 Cont…
 For example, if the agent is in the state Arad, there
are 3 possible actions,

 Arad  Zerind, Arad  Sibiu and Arad 

Timisoara, resulting in the states Zerind, Sibiu and
Timisoara respectively.

24
 Cont…
• A solution to a problem
 is an action sequence that leads from the initial state
to a goal state. Solution quality is measured by the
path cost function.
 An optimal solution has the lowest path cost among all
solutions.
• There fore, The solution to drive from Arad to Bucharest is
• Arad Sibiu Rimnicu Vicea Pitesti Bucharest
must be a solution.

25
 Example 2. Route-finding problem:

• Route- finding problem: is defined in terms of specified

locations and transitions along links between them.

 Route-finding algorithms are used in a variety of

applications such as, websites, in car systems to provide
driving directions, routing video streams in computer
networks, military operations planning, airline travel
planning systems.

26
 Consider the air line travel problems: that must be solved by a travel-
planning web site:

• States: Each state obviously includes a location (airport) and

the current time. Furthermore, the state must record extra
information like, base fare, flight segment, their status as
domestic or international, to decide the cost of an action.

• Initial state: This is specified by the user’s query.

• Actions: Take any flight from the current location, in any
seat class, leaving the current time, leaving enough time
for within airport transfer if needed.

27
 Cont..
• Transition model: The state resulting from taking a flight will
have the flight’s destination as the current location and the
flight’s arrival time as the current time.

• Goal Test: Are the final destination specified by the user?

• Path cost: This depends on monetary cost, waiting time, flight
time, customs and immigration procedures, seat quality, time of
day, type of airplane, frequent flyer mileage awards and so
on.

28
 Toy problems: Example
• 1. 8-Puzzle: Consists of a 3×3 board with eight
numbered tiles and a blank space. A tile adjacent to the
blank space can slide into the space. The objective is
to reach a specified goal state.

29
 Cont..
 States: 3 x 3 array configuration each of the eight tiles on
the board and the blank in one of the nine squares.

 Initial State: a figure given in the initial state configuration.

 Actions: The simplest formulation defines the action on
movements of the blank space Left, Right, Up or Down.

 Transition Model: Given a state and action, this returns the

resulting state.

30
 Cont..
 Goal Test: This checks whether the state matches
the goal configuration as shown in figure.

 Path cost: Each cost costs 1, so the path cost in the number of
steps in the path.

• Note: The8-puzzle belongs to the family of sliding-block

puzzles, which are often used as test problems for new
search algorithms in AI.

31
Exercise

32
 Exercise 1: River Crossing Puzzles
Missionary-and-cannibal problem
 Three missionaries and three cannibals are on one side of a
river that they wish to cross. There is a boat that can hold
one or two people. Find an action sequence that brings
everyone safely to the opposite bank (i.e. Cross the river).
But you must never leave a group of missionaries
outnumbered by cannibals on the same bank (in any place).
• 🞑Identify the set of possible states and operators
• 🞑Construct the state space of the problem using suitable
representation

33
 Exercise 2
• Goat, Wolf and Cabbage problem
 A farmer returns from the market, where he bought a goat, a cabbage
and a wolf. On the way home he must cross a river. His boat is small
and unable to transport more than one of his purchases. He cannot
leave the goat alone with the cabbage (because the goat would eat it),
nor he can leave the goat alone with the wolf (because the goat would
be eaten). How can the farmer get everything safely on the other side?

 Identify the set of possible states and operators

 Construct the state space of the problem using suitable representation

34
 Search Algorithms in Artificial Intelligence

• Search algorithms are one of the most important

areas of Artificial Intelligence. This topic will
explain all about the search algorithms in AI.
 Problem-solving agents:
In Artificial Intelligence, Search techniques are
universal problem-solving methods. Rational
agents or Problem-solving agents in AI mostly used
these search strategies or algorithms to solve a
specific problem and provide the best result.
Problem-solving agents are the goal-based agents and
use atomic representation. In this topic, we will learn
various problem-solving search algorithms.
35
 Search Algorithm Terminologies:
• Search: Searching is a step by step procedure to solve a
search-problem in a given search space. A search problem can
have three main factors:
a) Search Space: Search space represents a set of possible
solutions, which a system may have.
b) Start State: It is a state from where agent begins the search.
c) Goal test: It is a function which observe the current state
and returns whether the goal state is achieved or not.
• Search tree: A tree representation of search problem is called
Search tree. The root of the search tree is the root node which is
corresponding to the initial state.
• Actions: It gives the description of all the available actions to the
agent.
• Transition model: A description of what each action do, can be
represented as a transition model.

36
 Cont.
• Path Cost: It is a function which assigns a numeric
cost to each path.
• Solution: It is an action sequence which leads from
the start node to the goal node.
• Optimal Solution: If a solution has the lowest cost
among all solutions.

37
 Properties of Search Algorithms:
• Following are the four essential properties of search
algorithms to compare the efficiency of these algorithms:
• Completeness: A search algorithm is said to be complete if
it guarantees to return a solution if at least any solution
exists for any random input.
• Optimality: If a solution found for an algorithm is
guaranteed to be the best solution (lowest path cost)
among all other solutions, then such a solution for is said to
be an optimal solution.
• Time Complexity: Time complexity is a measure of time for
an algorithm to complete its task.
• Space Complexity: It is the maximum storage space
required at any point during the search, as the complexity
of the problem.
38
 Types of search algorithms
• Based on the search problems we can classify the
search algorithms into uninformed (Blind search)
search and informed search (Heuristic search)
algorithms.

39
Cont.

40
 Uninformed/Blind Search:
• The uninformed search does not contain any
domain knowledge such as closeness, the location
of the goal. It operates in a brute-force way as it
only includes information about how to traverse
the tree and how to identify leaf and goal nodes.
Uninformed search applies a way in which search
tree is searched without any information about the
search space like initial state operators and test for
the goal, so it is also called blind search. It
examines each node of the tree until it achieves the
goal node.

41
 Cont..
• It can be divided into six main types:
1. Breadth-first Search
2. Depth-first Search
3. Depth-limited Search
4. Iterative deepening depth-first search
5. Uniform cost search
6. Bidirectional Search

42
 Informed Search
 informed search algorithms use domain knowledge. In an
informed search, problem information is available which
can guide the search. Informed search strategies can find a
solution more efficiently than an uninformed search
strategy. Informed search is also called a Heuristic search.
 A heuristic is a way which might not always be guaranteed
for best solutions but guaranteed to find a good solution in
reasonable time.
 Informed search can solve much complex problem which
could not be solved in another way.
 An example of informed search algorithms is a traveling
salesman problem.
 Greedy Search
 A* Search

43
 1. 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.
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.
44
 Cont.
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.

45
 Example:
• In the below tree structure, we have shown the
traversing of the tree using BFS algorithm from the
root node S to goal node K. BFS search algorithm
traverse in layers, so it will follow the path which
is shown by the dotted arrow, and the traversed
path will be:
• S---> A--->B---->C--->D---->G--->H--->E---->F----
>I---->K

46
BFS

47
 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) = b+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.

48
 Example
• Calculate the time and memory requirement for breadth
first search, the number shown assume branching factor
b=10; 1 million node/second, 1000 bytes/node. Hint
d=depth is equal to 2, 8, 1 bytes is equal to
0.0009765625 kilobytes
Answer :
The time and space coplexity of breadth frist search is
computer as T (b) = O (bd)
Therefore: for d= 2: the time complexity is 0.11 millisecond
and 107 kilobytes memory requirement.
for d= 8: the time complexity is 2 minutes and 103 GB
memory requirement.

49
 How does BFS implemented with FIFO queue data
structure
Exercise
• Illustrate steps by steps how to implement FIFO
queue data structure in the following tree hint :
finally the queue become empty and BFS become :
A>>B>>C>>D>>E>>E>>F>>G

50
 2. Depth-first Search
• Depth-first search is a recursive algorithm for
traversing a tree or graph data structure.
• 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.
• DFS uses a stack data structure for its
implementation(LIFO).
• The process of the DFS algorithm is similar to the
BFS algorithm.

51
 Advantage and Disadvantage of DFS
Advantage:
• 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).
Disadvantage:
• 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.

52
 Example:
• In the below search tree, we have 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.

53
Cont.

54
 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)= n+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.

55
 3. Depth-Limited Search Algorithm:
• A depth-limited search algorithm is similar to
depth-first search with a predetermined limit.
Depth-limited search can solve the drawback of
the infinite path in the Depth-first search. In this
algorithm, the node at the depth limit will treat as
it has no successor nodes further.
• Depth-limited search can be terminated with two
Conditions of failure:
1. Standard failure value: It indicates that problem
does not have any solution.
2. Cutoff failure value: It defines no solution for the
problem within a given depth limit.
56
 Cont
Advantages:
• Depth-limited search is Memory efficient.
Disadvantages:
• Depth-limited search also has a disadvantage of
incompleteness.
• It may not be optimal if the problem has more
than one solution.

57
Example : assume level 2

58
 Cont.
• Completeness: DLS search algorithm is complete if
the solution is above the depth-limit.
• Time Complexity: Time complexity of DLS
algorithm is O(bℓ).
• Space Complexity: Space complexity of DLS
algorithm is O(b×ℓ).
• Optimal: Depth-limited search can be viewed as a
special case of DFS, and it is also not optimal even
if ℓ>d.

59
 4. 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.
Advantages:
• Uniform cost search is optimal because at every state the path with the
least cost is chosen.
Disadvantages:
• It does not care about the number of steps involve in searching and only
concerned about path cost.
60
Example

61
 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.

62
5. Iterative deepening depth-first Search:
• The iterative deepening algorithm is a combination of
DFS and BFS algorithms. This search algorithm finds
out the best depth limit and does it by gradually
increasing the limit until a goal is found.
• This algorithm performs depth-first search up to a
certain "depth limit", and it keeps increasing the depth
limit after each iteration until the goal node is found.
• This Search algorithm combines the benefits of
Breadth-first search's fast search and depth-first search's
memory efficiency.
• The iterative search algorithm is useful uninformed
search when search space is large, and depth of goal
node is unknown.
63
 Cont.
Advantages:
• It combines the benefits of BFS and DFS search
algorithm in terms of fast search and memory
efficiency.
Disadvantages:
• The main drawback of IDDFS is that it repeats all
the work of the previous phase.

64
 Example:
• Following tree structure is showing the iterative deepening
depth-first search. IDDFS algorithm performs various iterations
until it does not find the goal node. The iteration performed by
the algorithm is given as:

65
 Cont..
• 1'st Iteration-----> A
2'nd Iteration----> A, B, C
3'rd Iteration------>A, B, D, E, C, F, G
4'th Iteration------>A, B, D, H, I, E, C, F, K, G
In the fourth iteration, the algorithm will find the
goal node.

66
 cont
• Completeness:
• This algorithm is complete is if the branching factor
is finite.
• Time Complexity:
• Let's suppose b is the branching factor and depth is
d then the worst-case time complexity is O(bd).
• Space Complexity:
• The space complexity of IDDFS will be O(bd).
• Optimal:
• IDDFS algorithm is optimal if path cost is a non-
decreasing function of the depth of the node.
67
 6. Bidirectional Search Algorithm:

• Bidirectional search algorithm runs two

simultaneous searches, one form initial state called
as forward-search and other from goal node called
as backward-search, to find the goal node.
Bidirectional search replaces one single search
graph with two small subgraphs in which one
starts the search from an initial vertex and other
starts from goal vertex. The search stops when
these two graphs intersect each other.
• Bidirectional search can use search techniques such
as BFS, DFS, DLS, etc.
68
 Cont.
Advantages:
• Bidirectional search is fast.
• Bidirectional search requires less memory
Disadvantages:
• Implementation of the bidirectional search tree is
difficult.
• In bidirectional search, one should know the goal
state in advance.

69
 Example:
• In the below search tree, bidirectional search algorithm is
applied. This algorithm divides one graph/tree into two sub-
graphs. It starts traversing from node 1 in the forward direction
and starts from goal node 16 in the backward direction.
• The algorithm terminates at node 9 where two searches meet.

70
 Cont..
• Completeness: Bidirectional Search is complete if
we use BFS in both searches.
• Time Complexity: Time complexity of bidirectional
search using BFS is O(bd).
• Space Complexity: Space complexity of
bidirectional search is O(bd).
• Optimal: Bidirectional search is Optimal.

71
 Informed Search Algorithms
• So far we have talked about the uninformed search
algorithms which looked through search space for all
possible solutions of the problem without having any
additional knowledge about search space. But
informed search algorithm contains an array of
knowledge such as how far we are from the goal, path
cost, how to reach to goal node, etc. This knowledge
help agents to explore less to the search space and find
more efficiently the goal node.
• The informed search algorithm is more useful for large
search space. Informed search algorithm uses the idea
of heuristic, so it is also called Heuristic search.
72
 Cont.
• Heuristics function: Heuristic is a function which is
used in Informed Search, and it finds the most
promising path. It takes the current state of the
agent as its input and produces the estimation of
how close agent is from the goal. The heuristic
method, however, might not always give the best
solution, but it guaranteed to find a good solution
in reasonable time. Heuristic function estimates
how close a state is to the goal. It is represented by
h(n), and it calculates the cost of an optimal path
between the pair of states. The value of the
heuristic function is always positive.

73
 In the informed search we will discuss two main
algorithms which are given below:
• Best First Search Algorithm(Greedy search)
• A* Search Algorithm

74
1.) Best-first Search Algorithm (Greedy Search)
• Greedy best-first search algorithm always selects the
path which appears best at that moment. It is the
combination of depth-first search and breadth-first
search algorithms.
• It uses the heuristic function and search. Best-first
search allows us to take the advantages of both
algorithms.
• f(n)= g(n).
• Were, h(n)= estimated cost from node n to the goal.
• The greedy best first algorithm is implemented by the
priority queue.

75
 Best first search algorithm:
Step 1: Place the starting node into the OPEN list.
Step 2: If the OPEN list is empty, Stop and return failure.
Step 3: Remove the node n, from the OPEN list which has the
lowest value of h(n), and places it in the CLOSED list.
Step 4: Expand the node n, and generate the successors of
node n.
Step 5: Check each successor of node n, and find whether any
node is a goal node or not. If any successor node is goal
node, then return success and terminate the search, else
proceed to Step 6.
Step 6: For each successor node, algorithm checks for
evaluation function f(n), and then check if the node has been
in either OPEN or CLOSED list. If the node has not been in
both list, then add it to the OPEN list.
Step 7: Return to Step 2.
76
 Cont..
Advantages
• Best first search can switch between BFS and DFS
by gaining the advantages of both the algorithms.
• This algorithm is more efficient than BFS and DFS
algorithms.
Disadvantages
• It can behave as an unguided depth-first search in
the worst case scenario.
• It can get stuck in a loop as DFS.
• This algorithm is not optimal.
77
 Example:
• Consider the below search problem, and we will
traverse it using greedy best-first search. At each
iteration, each node is expanded using evaluation
function f(n)=h(n) , which is given in the below
table.

78
 Cont…
• In this search example, we are using two lists
which are OPEN and CLOSED Lists. Following are
the iteration for traversing the above example.

79
 Cont.
• Expand the nodes of S and put in the CLOSED list
• Initialization: Open [A, B], Closed [S]
• Iteration 1: Open [A], Closed [S, B]
• Iteration 2: Open [E, F, A], Closed [S, B]
: Open [E, A], Closed [S, B, F]
• Iteration 3: Open [I, G, E, A], Closed [S, B, F]
: Open [I, E, A], Closed [S, B, F, G]
• Hence the final solution path will be: S----> B-----
>F----> G

80
 Cont..
• Time Complexity: The worst case time complexity
of Greedy best first search is O(bm).
• Space Complexity: The worst case space
complexity of Greedy best first search is O(bm).
Where, m is the maximum depth of the search
space.
• Complete: Greedy best-first search is also
incomplete,
• Optimal: Greedy best first search algorithm is not
optimal.

81
 2.) A* Search Algorithm:
• A* search is the most commonly known form of
best-first search. It uses heuristic function h(n), and
cost to reach the node n from the start state g(n).
It has combined features of UCS and greedy best-
first search, by which it solve the problem
efficiently. A* search algorithm finds the shortest
path through the search space using the heuristic
function. This search algorithm expands less search
tree and provides optimal result faster. A*
algorithm is similar to UCS except that it uses
g(n)+h(n) instead of g(n).

82
 Cont..
• In A* search algorithm, we use search heuristic as
well as the cost to reach the node. Hence we can
combine both costs as following, and this sum is
called as a fitness number.

83
 Algorithm of A* search:
Step1: Place the starting node in the OPEN list.
Step 2: Check if the OPEN list is empty or not, if the list is
empty then return failure and stops.
Step 3: Select the node from the OPEN list which has the
smallest value of evaluation function (g+h), if node n is goal
node then return success and stop, otherwise
Step 4: Expand node n and generate all of its successors, and
put n into the closed list. For each successor n', check whether
n' is already in the OPEN or CLOSED list, if not then compute
evaluation function for n' and place into Open list.
Step 5: Else if node n' is already in OPEN and CLOSED, then it
should be attached to the back pointer which reflects the
lowest g(n') value.
Step 6: Return to Step 2.

84
 Cont.
Advantages:
• A* search algorithm is the best algorithm than other
search algorithms.
• A* search algorithm is optimal and complete.
• This algorithm can solve very complex problems.
Disadvantages:
• It does not always produce the shortest path as it
mostly based on heuristics and approximation.
• A* search algorithm has some complexity issues.
• The main drawback of A* is memory requirement as it
keeps all generated nodes in the memory, so it is not
practical for various large-scale problems.
85
 Example:
• In this example, we will traverse the given graph
using the A* algorithm. The heuristic value of all
states is given in the below table so we will
calculate the f(n) of each state using the formula
f(n)= g(n) + h(n), where g(n) is the cost to reach
any node from start state.
• Here we will use OPEN and CLOSED list.

86
Cont.…

87
cont

88
 Cont.
Complete: A* algorithm is complete as long as:
 Branching factor is finite.
 Cost at every action is fixed.
Optimal: A* search algorithm is optimal
Time Complexity: The time complexity of A* search
algorithm depends on heuristic function, and the
number of nodes expanded is exponential to the
depth of solution d. So the time complexity is
O(b^d), where b is the branching factor.
Space Complexity: The space complexity of A*
search algorithm is O(b^d)

89
 Search algorithm implementation
• Search algorithm implementation by python
programming language in Lab class

90
 Thank You!

End of chapter Three !

? 91