Uninformed Search Strategies for Solving Puzzles

Uninformed Search Strategies
CSI 341 Mohammad Imam Hossain | Lecturer, Dept. of CSE | UIU

Search >> 8-puzzle
Let’s consider 8-puzzle game.
2
Mohammad Imam Hossain | Lecturer, Dept. of CSE | UIU
Initial State Goal State
(Game Over)
how?

Search >> 8-puzzle
Search >> The process of looking for a sequence
of actions that reaches the goal state is called
search.
Search algorithm >> It takes input a problem,
constructs the search tree and returns a solution
in the form of an action sequence.
State space graph >>
- nodes = different states
- edges = different actions
Search tree >>
- root = initial state
- nodes = states of state space graph
- branches = actions
3

Search >> 8-puzzle
Step cost >> The cost related to action a to go
from state s to state s’
Path cost >> The sum of all step costs of the
individual actions along the path.
Solution >> It is an action sequence(path of
search tree) that leads from the initial state to a
goal state.
Optimal solution >> The solution that has the
lowest path cost among all the solutions.
4

Search >> 8-puzzle
5
How to build up this
search tree?
&
How to find the solution?

TreeSearch( ) =
Search Algorithm >> Tree Search
6
S
B
D
G B
S
S
D
G S G
Problems
Loopy path: S -> B -> S …
and S -> D -> S …
Redundant path: S -> B -> G
and S -> D -> G

GraphSearch( ) =
Search Algorithm >> Graph Search
7
S
B
D
G B
S
D
G
Here the search tree contains at
most 1 copy of each state by
tracking the already visited nodes
from explored set.
So minimizes redundant paths.

Performance Measure >> Search Algorithm
The performance of specific search algorithms is evaluated in the following 4 ways:
▸Completeness: Is the algorithm guaranteed to find a solution when there is one?
▸Optimality: Does the strategy find the optimal solution?
▸Time complexity: How long does it take to find a solution?
▸Space complexity: How much memory is needed to perform the search?
Time and space complexities are expressed in terms of :
▸b = branching factor, maximum no of successors of any node.
▸d = the depth of the shallowest goal node.
▸m = the maximum length of any path in the state space.
Time complexity >> It is often measured in terms of the number of nodes generated during the search.
Space complexity >> It is measured in terms of maximum number of nodes stored in memory.
8

Search Strategy
Search Strategy >> The process of expanding nodes until either a solution is found or there are no more states to expand.
Uninformed/Blind Search Strategy >>
- This strategy has no additional information about the states beyond in the problem definition.
- All they can do is generate successors and distinguish a goal state from non-goal state.
Informed/Heuristic Search Strategy >>
- This strategy uses problem-specific knowledge beyond the definition of the problem itself.
- It can find solutions more efficiently than can an uninformed strategy.
- This strategy knows whether one non-goal state is more promising than another.
9

Uninformed Search Strategy
Different types of uninformed search strategies are:
▸Breadth-first search (BFS)
▸Uniform-cost search (UCS)
▸Depth-first search (DFS)
▸Depth-limited search (DLS)
▸Iterative deepening depth-first search (ID DFS)
▸Bidirectional search
10

1. Breadth-first search
▸BFS is a simple strategy in which the root node is expanded first,
then all the successors of the root node are expanded next,
then their successors,
and so on.
▸Here the shallowest unexpanded node is chosen for expansion.
▸Frontier >> The set of all nodes(leaf nodes) available for expansion at any given point is called the frontier.
▸BFS uses a FIFO queue for the frontier, thus new nodes go to the back of the queue and old nodes which are shallower
than the new nodes get expanded first.
11

1. Breadth-first search >> Algorithm [Graph Search]
12

1. Breadth-first search >> How it searches!
13

1. Breadth-first search >> Example
14
State Space : S = initial state, G =goal state, other nodes = intermediate states and links = legal transitions.
S G
A B
D E
C
F

15
S G
A B
D E
C
F
S
Before :
Frontier = { }
Explored = { }
Process:
Node = initial state = S
Final:
Goal(Node) = False
Frontier = { S }
Explored = { }

16
S G
A B
D E
C
F
Before :
Frontier = { S }
Explored = { }
Process:
Node = Pop(Frontier) = S
Child = Expand S = { A, D }
Final:
Goal(Child) = False
Frontier = { A, D }
Explored = { S }
S
A D

17
S G
A B
D E
C
F
Before :
Frontier = { A, D }
Explored = { S }
Process:
Node = Pop(Frontier) = A
Child = Expand A = { B, S, D }
Final:
Goal(Child) = False
Frontier = { D, B }
Explored = { S, A }
S
A D
B

18
S G
A B
D E
C
F
Before :
Frontier = { D, B }
Explored = { S, A }
Process:
Node = Pop(Frontier) = D
Child = Expand D = { E, S, A }
Final:
Goal(Child) = False
Frontier = { B, E }
Explored = { S, A, D }
S
A D
B E

19
S G
A B
D E
C
F
Before :
Frontier = { B, E }
Explored = { S, A, D }
Process:
Node = Pop(Frontier) = B
Child = Expand B = { C, A, E }
Final:
Goal(Child) = False
Frontier = { E, C }
Explored = { S, A, D, B }
S
A D
B E
C

20
S G
A B
D E
C
F
Before :
Frontier = { E, C }
Explored = { S, A, D, B }
Process:
Node = Pop(Frontier) = E
Child = Expand E = { F, D, B }
Final:
Goal(Child) = False
Frontier = { C, F }
Explored = { S, A, D, B, E }
S
A D
B E
C
F

21
S G
A B
D E
C
F
Before :
Frontier = { C, F }
Explored = { S, A, D, B, E }
Process:
Node = Pop(Frontier) = C
Child = Expand C = { B }
Final:
Goal(Child) = False
Frontier = { F }
Explored = { S, A, D, B, E, C }
S
A D
B E
C
F

22
S G
A B
D E
C
F
Before :
Frontier = { F }
Explored = { S, A, D, B, E, C }
Process:
Node = Pop(Frontier) = F
Child = Expand F = { G, E }
Final:
Goal(Child) = True
return
S
A D
B E
C
F
G

1. Breadth-first search >> Performance Measure
23
Complete >> Yes if the branching factor b is finite.
Optimal >> Yes if step costs are all identical.
Time Complexity >>
- depth 1: nodes generated = b
- depth 2: nodes generated= b * b = b2
- depth 3: nodes generated = b2 * b = b3
… … …
- depth d: nodes generated = bd
So, Total number of nodes generated = b + b2 + b3 + … … … + bd-1 + bd = O(bd)
Space Complexity >> Total = O(bd)
b + b2 + b3 + … … … + bd-1 + bd
Explored set = O(bd-1)
Frontier set = O(bd)
What is time and space complexity
when the goal test is checked during
popping states from the frontier?

2. Uniform-cost search
24
▸Similar to BFS but gives optimal solution with any step-cost function.
▸It expands the node with the lowest path cost g(n)
▸It uses priority queue that sorts based on g(n) value
▸Here, goal test is applied to a node when it is selected for expansion rather than when it is first generated.
▸Also an extra checkpoint is added in case a better path is found to a node currently on the frontier.

2. Uniform-cost search >> Algorithm [Graph Search]
25

2. Uniform-cost search >> How it searches!
26

2. Uniform-cost search >> Example
27
State Space : S = initial state, G =goal state, other nodes = intermediate states, links = legal transitions, labels = step cost.
S
C
B
A
G
1 10
5 5
15
5

28
Before :
Frontier = { }
Explored = { }
Process:
Node = Initial State = S
Final:
Frontier = { (S,0,Nil) }
Explored = { }
S

29
Before :
Frontier = { (S,0, Nil) }
Explored = { }
Process:
Node = Pop(Frontier) = (S,0, Nil)
Goal(Node) = False
Child={ A, B, C }
Final:
Frontier = { (A,1,S), (B,5,S), (C,15,S) }
Explored = { (S,0,Nil) }
S
A
1
B
5
C
15

30
Before :
Frontier = { (A,1,S), (B,5,S), (C,15,S) }
Explored = { (S,0,Nil) }
Process:
Node = Pop(Frontier) = (A,1,S)
Goal(Node) = False
Child={ G, S }
Final:
Frontier = { (B,5,S), (G,11,A),(C,15,S) }
Explored = { (S,0,Nil), (A,1,S) }
S
A 1B
5
C
15
11
G

31
Before :
Frontier = { (B,5,S), (G,11,A), (C,15,S) }
Explored = { (S,0,Nil), (A,1,S) }
Process:
Node = Pop(Frontier) = (B,5,S)
Goal(Node) = False
Child={ G, S }
Final:
Frontier = { (G,10,B), (C,15,S) }
Explored = { (S,0,Nil), (A,1,S), (B,5,S) }
S
A 1B
5
C
15
10
G

32
Before :
Frontier = { (G,10,B), (C,15,S) }
Explored = { (S,0,Nil), (A,1,S), (B,5,S) }
Process:
Node = Pop(Frontier) = (G,10,B)
Goal(Node) = True
return
S
A 1B
5
C
15
10
G

2. Uniform-cost search >> Performance Measure
33
Complete >> Yes if branching factor b is finite and step costs is >= some positive constant ϵ
Optimal >> Yes
Time Complexity >>
-- Here Final depth = 1 + floor(C*/ϵ) where C* = cost of the optimal solution
-- So Time Complexity = O(bdepth) = O(b1+floor(C*/ϵ))
Space Complexity >> As we need to save all the nodes either in Explored/Frontier Set, So required space= O(b1+floor(C*/ϵ))

3. Depth-first Search
34
▸Expand deepest unexpanded node.
▸DFS uses LIFO queue as Frontier.
▸LIFO queue means that the most recently generated node is chosen for expansion as this node must be the deepest
unexpanded node cause it is one deeper than its parent.

3. Depth-first Search >> Algorithm [Tree Search]
35
function DFS(problem) returns a solution, or failure
node  problem.INITIAL-STATE, PATH-COST = 0
frontier  a LIFO queue with node as the only element
loop do
if Empty?(frontier) then return failure
node  POP(frontier)
if problem.GOAL-STATE(node.STATE) then return SOLUTION(node)
for each action in problem.ACTIONS(node.STATE) do
child  CHILD-NODE(problem, node, action)
if child not in current-path do
frontier  INSERT(child, frontier)
[ Here, frontier works like a LIFO queue ]

3. Depth-first Search >> How it works!
36

3. Depth-first Search >> Example
37
S G
A B
D E
C
F
Before :
Frontier = { S }
Process:
Node = Pop(Frontier) = S
Goal(Node) = False
Child = Expand S = { A, D }
Final:
Frontier = { A, D }
S
A D

38
S G
A B
D E
C
F
Before :
Frontier = { A, D }
Process:
Node = Pop(Frontier) = A
Goal(Node) = False
Child = Expand A = { B, D, S }
Final:
Frontier = { B, D, D }
S
A D
B D

39
S G
A B
D E
C
F
Before :
Frontier = { B, D, D }
Process:
Node = Pop(Frontier) = B
Goal(Node) = False
Child = Expand B = { C, E, A }
Final:
Frontier = { C, E, D, D }
S
A D
B D
EC

40
S G
A B
D E
C
F
Before :
Frontier = { C, E, D, D }
Process:
Node = Pop(Frontier) = C
Goal(Node) = False
Child = Expand C = { B }
Final:
Frontier = { E, D, D }
S
A D
B D
EC

41
S G
A B
D E
C
F
Before :
Frontier = { E, D, D }
Process:
Node = Pop(Frontier) = E
Goal(Node) = False
Child = Expand E = { D, F, B }
Final:
Frontier = { D, F, D, D }
S
A D
B D
EC
D F

42
S G
A B
D E
C
F
Before :
Frontier = { D, F, D, D }
Process:
Node = Pop(Frontier) = D
Goal(Node) = False
Child = Expand D = { S, A, E }
Final:
Frontier = { F, D, D }
S
A D
B D
EC
D F

43
S G
A B
D E
C
F
Before :
Frontier = { F, D, D }
Process:
Node = Pop(Frontier) = F
Goal(Node) = False
Child = Expand S = { G }
Final:
Frontier = { G, D, D }
S
A D
B D
EC
D F
G

44
S G
A B
D E
C
F
Before :
Frontier = { G, D, D }
Process:
Node = Pop(Frontier) = G
Goal(Node) = True
S
A D
B D
EC
D F
G

3. Depth-first search >> Performance Measure
45
Complete >> No
Optimal >> No
Time Complexity >>
- If maximum tree depth = m ; m>=d
- Then DFS will generate maximum O(bm) nodes
assuming 1 goal leaf at the RHS at depth d
Space Complexity >>
- At depth m we have b nodes
- and (b-1) nodes at earlier depths from depth 0 to m-1
- Total = b+(m-1)*(b-1) = O(bm) nodes

4. Depth-limited Search
46
▸It solves the infinite-path problem by providing a depth limit = l
▸If l < d then this problem will be incomplete
▸If l >d then this problem solution will be non-optimal
▸Depth-limit can be selected based on problem knowledge, but typically not known ahead of time in practice
▸This search algorithm returns two kinds of failures:
- standard failure indicates no solution
- cutoff indicates no solution within that depth limit

4. Depth-limited Search >> Algorithm [Tree Search]
47
function DLS(problem) returns a solution, or failure
node  problem.Initial-state, Path-cost=0
frontier  a LIFO queue with node as the only element
limit= l
loop do
if Empty?(frontier) then return failure
node  Pop(frontier)
if problem.Goal-state(node.State) then return Solution(node)
if depth == l then return cutoff
else expand the chosen node, adding the resulting nodes to the frontier if not in the path.
end loop
[ Here, frontier works like a LIFO queue ]

4. Depth-limited Search >> How it works!
48

4. Depth-limited search >> Performance Measure
49
Complete >> No when depth limit < d
Optimal >> No when depth limit >= d
Time Complexity >>
- If maximum tree depth = l
- Then DLS will generate maximum O(bl) nodes
assuming 1 goal leaf at the RHS at depth d
Space Complexity >>
- At depth l we have b nodes
- and (b-1) nodes at earlier depths
- Total = b+(l-1)*(b-1) = O(bl) nodes

5. Iterative Deepening DFS Search
50
▸Run multiple DFS searches with increasing depth-limits
▸It combines the benefits of DFS and BFS
-- Like DFS it’s memory requirements are modest: O(bd)
-- Like BFS, it is complete when the branching factor is finite and optimal when the path cost is a non-decreasing
function of the depth of the node.

5. Iterative Deepening DFS Search >> How it works!
51

5. Iterative Deepening DFS Search >> Example
52

5. Iterative Deepening DFS Search >> Example
53

5. Iterative Deepening DFS Search >> Performance Measure
54
Complete >> Yes if branching factor b is finite.
Optimal >> Yes if step costs are all identical
No if step costs are different.
Time Complexity >>
- Total no. of nodes=
b + (b+b2) + … … … + (b+b2+ … … + bd) = O(bd)
Space Complexity >>
- O(bd)

5. Iterative Deepening DFS Search >> When to use?
55
▸Isn’t IDS wasteful?
- Repeated searches on different iterations
- Compare IDS and BFS:
E.g., b = 10 and d = 5
N(IDS) ~ db + (d-1)b2 +… … + bd = 50+400+3000+20000+100000 = 123,450
N(BFS) = b + b2 +… … + bd = 10+100+1000+10000+100000 =111,110
- Difference is only about 10%
- Most of the time is spent at depth d, which is the same amount of time in both algorithms
▸In practice, IDS is the preferred uninformed search method with a large search space and unknown solution depth

Practice 1
56
Apply the following search strategies in the state space graph as shown and show the corresponding search trees, solution
paths and path costs.
- BFS
- DFS
- IDS
- UCS

Previous Question
57
- BFS
- DFS
- IDS
- UCS

Previous Question
58
- BFS
- DFS
- IDS
- UCS

Previous Question
59
- BFS
- DFS
- IDS
- UCS

Previous Question
60
- BFS
- DFS
- IDS
- UCS

Previous Question
61
- BFS
- DFS
- IDS
- UCS

62
THANKS!
Any questions?
You can find me at imam@cse.uiu.ac.bd

Uninformed Search Strategies for Solving Puzzles

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Uninformed Search Strategies for Solving Puzzles

Similar to Uninformed Search Strategies for Solving Puzzles (13)

More from Mohammad Imam Hossain

More from Mohammad Imam Hossain (20)

Recently uploaded

Recently uploaded (20)

Uninformed Search Strategies for Solving Puzzles