3 Ch. Search
Supplemental slides for
CSE 327
Prof. Jeff Heflin
8-Puzzle Transition Model
7
2
5
8
4
state s
6
3
1
actions a
blank-right
7
2
5
6
8
3
blank-left
4
8
2
4
6
5
3
1
8
blank-down
7
5
1
7
blank-up
RESULT(s,a)
4
7
2
4
2
6
5
3
6
3
1
8
1
8-puzzle Search Tree
7
4
8
6
3
7
2
5
initial state
1
7
8
6
5
3
1
7
7
2
4
6
5
8
6
5
4
4
8
2
2
3
1
2
4
7
2
4
7
6
5
8
6
5
3
1
8
5
3
1
3
3
2
1
7
2
4
7
2
4
6
8
4
5
8
6
5
8
6
3
1
3
1
1
Tree Search Algorithm
function Tree-Search(problem) returns a solution, or failure
initialize the frontier using the initial state of problem
loop do
if the frontier is empty then return failure
choose a leaf node and remove it from the frontier
if the node contains a goal state
then return the corresponding solution
expand the chosen node, adding the resulting nodes to the frontier
From Figure 3.7, p. 77
Problem Solving Agent Algorithm
function Simple-Problem-Solving-Agent(percept)
returns an action
persistent: seq, an action sequence, initially empty
state, some description of the current world state
goal, a goal, initially null
problem, a problem formulation
state Update-State(state,percept)
if seq is empty then
goal Formulate-Goal(state)
problem Formulate-Problem(state,goal)
seq Search(problem)
if seq = failure then return a null action
action First(seq)
seq Rest(seq)
return action
From Figure 3.1, p. 67
a
c
t
i
o
n
s
/
s
u
c
c
e
s
s
o
r
f
Water Jug Problem
state: <J12, J8, J3>
initial state: <0, 0, 0>
goal test: <1, x, y>
x and y can be any value
path cost:
1 per solution step?
1 per gallon of water moved?
Depth-first Search
1
A
not generated
on frontier
2
7
B
in memory
deleted
3
E
5
H
8
6
D
4
C
I
9
F
G
Breadth-first Search
1
A
not generated
on frontier
2
3
B
in memory
deleted
4
5
D
8
6
E
9
H
C
I
7
F
G
Uniform Cost Search
State space
Search tree
10
I
4
1
G
B
C
g(n)=0
5
3
I
2
B
g(n)=4
G
not frontier
in generated
on memory
deleted
4
3
C
g(n)=7
G
g(n)=9
g(n)=10
Repeated States
State space
A
Search tree
B
A
C
G
B
initial
state
goal
state
A
B
C
C
C
A
B
A
G
B
G
Uninformed Search Summary
depth-first
breadth-first
uniform cost
queuing
add to front
(LIFO)
add to back (FIFO)
by path cost
complete?
no
yes
yes, if all step costs
are greater than 0
optimal?
no
yes, if identical step yes, if all step costs
costs
are greater than 0
time
expensive
expensive
expensive
space
modest
expensive
expensive
A* Example
Use A* to solve the 8-puzzle:
initial state:
1
4
7
2
6
5
3
8
goal state:
1
4
7
2
5
8
3
6
path cost is the total number of moves made
Consider these heuristics
H1: The number of tiles out of place
H2: Sum of distances of tiles from goal positions
Ignore moves that return you to the previous state
A* on 8-puzzle
1
Heuristic = H1
2
123
4
8
765
123
468
7
5
f=2+3=5
Whether or not this node is
expanded depends on how you
break ties. It could be expanded at
any time or not at all.
123
468
75
f=0+3=3
3
f=1+3=4
123
46
f=1+3=4
758
123
468
75
1
f=2+4=6
3 f=3+3=6
426
758
4
123
4
6
758
123
46
f=2+2=4
12
f=2+4=6
463
758
f=3+3=6
5 1 2 3 f=3+1=4
456
7
8
758
123
456
78
f=4+2=6 6 1 2 3 f=4+0=4
456
78
A* on 8-puzzle
Heuristic = H2
123
468
7
5
1
123
468
75
f=0+4=4
2
f=1+5=6
123
46
f=1+3=4
758
3
1
3
426
758
f=3+3=6
123
4
6
758
123
46
f=3+3=6
12
f=2+2=4
f=2+4=6
463
758
4 1 2 3 f=3+1=4
456
7
8
758
123
456
78
f=4+2=6 5 1 2 3 f=4+0=4
456
78
Summary of Search Algorithms
type
ordering
optimal?
complete?
efficient?
depth-first
uninformed
LIFO
no
no
if lucky
breadth-first
uninformed
FIFO
yesa
yes
no
uniform cost
uninformed
g(n)
yesb
yesb
no
greedy
informed
h(n)
no
no
usually
A*
informed
g(n)+h(n)
yesc
yesb
yes
a if step costs are identical
b if step costs > 0
c if heuristic is admissible and consistent