1. CHAPTER - 2
Problem Spaces and
P roblem Solving by
Searching
Presented By :
Radhika Srinivasan PG
Roll No : 45

2. What we will learn today …
 What is Problem Spaces?
 How to Search to get solutions?
 Using Different searching algorithms i.e.
basically used in AI
 Some Toy problems and Real world problems

3. Introduction
Now, we’ll study about what are the kinds of problems
where the AI is concerned and the technique that is
used to solve those problems.
There are 4 things concerned to solve a particular
problem.
 Define the problem precisely.
 Analyze the problem.
 Isolate and represent the task knowledge i.e. required
to solve the problem.
 Finally, choose the best problem solving technique and
apply to the particular problem.

4. Areas
 Problem Solving
-Puzzles
-Play games, e.g chess
-Symbolic integration of mathematical formulas.
-Some programs can improve their performance with
experience
 Logical reasoning
– Prove assertions (theorems) by manipulating a database
of facts

5. Areas
 Language
– Understanding of natural language
– Translation
– E.g. Spelling checker
 Programming
– Write computer programs based on a description
 Systems and languages
– Time-sharing, list processing, and interactive debugging
were developed in the AI research

6. What is problem space ?
 Problem space is a set of states and the connections
between to represent the problem. Problem space graph
is used to represent a problem space. In the graph, the
states are represented by nodes of the graph, and the
operators by edges between nodes.
 For simplicity they are often represented as trees,
where the initial state is the root of the tree. The cost of
the simplification is that any state that can be reached
by two different paths will be represented by duplicate
nodes thereby increasing the tree size. The benefit of
using tree is that the absence of cycles greatly
simplifies many search algorithms.

7. Search
 State Space and Problem Reduction
– State space
 An operator produces exactly one new state
– Problem reduction
 An operator produces a set of sub problems, each of
which have to be solved.
- E.g.
Tower of Hanoi

8. Search - problem representation
 State space graph
 It is represented like nodes and edges where initial
state to the goal state. It can also represent as tree
graph.

9. Search Strategy
 A strategy is defined by picking the order of node
expansion. Strategy is evaluated among the following
dimensions.
 Completeness- does it always find a solution if one
exists?
 Time complexity- no. of nodes generated.
 Space complexity- max no. of nodes in memory.
 Optimality- does it always find least cost solution?
 Time and space is measured in ‘b’ – max branching
factor of search tree. ‘d’- depth of least cost solution.
‘m’ – max depth of the state space may be (infinite)

10. Which are the Search Types ?
 Blind search algorithms are as follows:
 In blind search the number of nodes can be
extremely large, The order of expanding the nodes is
arbitrary
- Breadth First Search
- Depth First Search
 Heuristic search
- Ordered Search
- A* An optimal search
 Consider State space graph as general graph i.e. nodes
and points. Graphs can be directed undirected or mixed
graph.

11. Breadth-First Search
 Breadth First Search (BFS) searches breadth-wise in
the problem space. Breadth-First search is like
traversing a tree where each node is a state which may
a be a potential candidate for solution.
 Breadth first search expands nodes from the root of the
tree and then generates one level of the tree at a time
until a solution is found. It is very easily implemented
by maintaining a queue of nodes.
 Initially the queue contains just the root. In each
iteration, node at the head of the queue is removed and
then expanded. The generated child nodes are then
added to the tail of the queue.

12. ALGORITHM: BREADTH-FIRST SEARCH
 Create a variable called NODE-LIST and set it to the
initial state.
 Loop until the goal state is found or NODE-LIST is
empty.
• Remove the first element, say E, from the NODE-
LIST. If NODE-LIST was empty then quit.
• For each way that each rule can match the state
described in E do:
 - Apply the rule to generate a new state.
- If the new state is the goal state, quit and return this
state.
- Otherwise add this state to the end of NODE-LIST

13. Advantages : BFS
 Breadth first search will never get trapped exploring the
useless path forever.
 If there is a solution, BFS will definitely find it out.
 If there is more than one solution then BFS can find the
minimal one that requires less number of steps.

14. Disadvantages :BFS
 The main drawback of Breadth first search is its
memory requirement. Since each level of the tree must
be saved in order to generate the next level, and the
amount of memory is proportional to the number of
nodes stored, the space complexity of BFS is O(bd).
 As a result, BFS is severely space-bound in practice so
will exhaust the memory available on typical computers
in a matter of minutes.
 If the solution is farther away from the root, breath first
search will consume lot of time.

15. DEPTH FIRST SEARCH
 Depth First Search (DFS) searches deeper into the
problem space.
 BFS always generates successor of the deepest
unexpanded node.
 Depth First Search uses last-in first-out stack for
keeping the unexpanded nodes.
 More commonly, depth-first search is implemented
recursively, with the recursion stack taking the place of
an explicit node stack.

16. ALGORITHM: DEPTH FIRST SEARCH
 If the initial state is a goal state, quit and return
success.
 Otherwise, loop until success or failure is signalled.
a) Generate a state, say E, and let it be the successor
of the initial state. If there is no successor, signal
failure.
b) Call Depth-First Search with E as the initial state.
c) If success is returned, signal success. Otherwise
continue in this loop.

17. ADVANTAGES
 The advantage of depth-first Search is that memory
requirement is only linear with respect to the search
graph.
 The time complexity of a depth-first Search to depth d
is O(b^d) since it generates the same set of nodes
as BFS.
 If depth-first search finds solution without exploring
much in a path then the time and space it takes will be
very less.

18. DISADVANTAGES
 There is a possibility that it may go down the left-most
path forever. Even a finite graph can generate an
infinite tree.
 Depth-First Search is not guaranteed to find the
solution.
 And there is no guarantee to find a minimal solution, if
more than one solution exists.

19. Bidirectional Search
 The algorithms so far use forward reasoning, i.e.
moving from the start node towards a goal node. some
cases we could use backward reasoning, i.e. moving
from the goal state to the start state.
 Forward and backward reasoning can be combined into
a technique called bidirectional search.
- One starting from the initial state and searching
forward
- One starting from the goal state and searching
backward The search terminates when the two graphs
intersect

20. Problems in Real World
 There are some toy searching that we’ll see
this technique are used to solve some real world
problems like:
 Route finding.(computer networks, airline travel
planning system)
 Layout problems (VLSI layout, furniture layout,
packaging)
 Assembly sequencing.(Assembly of electrical motors)
 Task Scheduling.(Time tables, manufacturing)

21. Water Jug Problem
 Consider the following problem:
A Water Jug Problem: You are given two jugs, a
4-gallon one and a 3-gallon one, a pump which has
unlimited water which you can use to fill the jug, and
the ground on which water may be poured. Neither jug
has any measuring markings on it. How can you get
exactly 2 gallons of water in the 4-gallon jug?
 State Representation and Initial State –
We will represent a state of the problem as a tuple
(x, y) where x represents the amount of water in the 4-
gallon jug and y represents the amount of water in the
3-gallon jug. Goal state as (2,y).

22. Production Rules
 (x,y)If x<4 -> (4,y)
 (x,y)If y<3 ->(x,3)
 (x,y)If x>0 ->(x-d,y)
 (x,y)If y>0 ->(x,y-d)
 (x,y)If x>0 ->(0,y)
 (x,y)If y>0 ->(x,0)
 (x,y)If(x+y>=4 and y>0) ->(4,y-(4-x))
 (x,y)If (x+y>=3 and x>0) ->(x-(3-y),3)
 (x,y)If(x+y<=4 and y>0) ->(x+y,0)
 (x,y)If (x+y<=3 and x>0) ->(0,x+y)
 (0,2)->(2,0)

23. Solution
4 Gallon Jug 3 Gallon Jug
0 0 pump
4 0
1 3
1 0
4 Gallon jug 0 1 3 Gallon jug
4 1
2 3

24. Search Tree : Water Jug Problem
(0,0)
(4,0) (0,3)
(4,3) (0,0) (1,3) (4,3) (0,0) (3,0)

25. 8 Puzzle Problem
1 3 5 1 2 3
2 7 4 4 5 6
6 8 7 8
Start State Goal State

26. 8 Puzzle Problem
 State space (S)
Location of each of the 8 tiles(and the blank tile)
 Start State (s)
Starting configuration
 Operators(O)
Four Operators : Right, Left, Up, Down
 Goals(G)
one of the goal configuration

27. 8 Queen Problem
 Problem: Place 8 queens on a chess board so that none
of them attack each other
 Formulation- I
- A state is an arrangement of 0 to 8 queens on the
board
- Operators add a queen to any square.
 This formulation is not a systematic way to find the
solution, it takes a long time to get the solution.

28. 8 Queen Problem
 Formulation – II
- A state is an arrangement of 0-8 queen with no one
attacked.
- Operators place a queen in the left most empty
column.
- More systematic than formulation-I

29. 8 Queen Problem
 Formulation –III
- A state is an arrangement of 8 queens on in each
column.
-Operators move an attacked queen to another square
in the same column.
-Keep on shuffling the queen until the goal is reached.
- This formulation is more systematic hence , it is also
called as Iterative Formulation.

30. 8 Queen Problem : Solution

31. Missionaries and Cannibals
 Three missionaries and three cannibals find themselves
on a side of river. They agreed to get to the other side
of river. But missionaries are afraid of being eaten by
cannibals so, the missionaries want to manage the trip
in such a way that no. of missionaries on either side of
the river is never less than the no. of cannibals on the
same side. The boat is able to hold only 2 people at a
time.

32. Missionaries and Cannibals
 State(#m,#c,1/0)
#m – number of missionaries on first bank
#c – number of cannibals on first bank
 The last bit indicate whether the boat is in the first
bank.
 Operators
• Boat carries (1,0) or (0,1) or (1,1) or (2,0) or (0,2)