View
212
Download
0
Category
Preview:
Citation preview
State Space Search
Backtracking
Suppose We are searching depth-first No further progress is possible (i.e.,
we can only generate nodes we’ve already generated), then backtrack.
The algorithm: First Pass
1. Pursue path until goal is reached or dead end
2. If goal, quit and return the path3. If dead end, backtrack until you
reach the most recent node whose children have not been fully examined
BT maintains Three Lists and A State
SL– List of nodes in current path being tried. If goal
is found, SL contains the path NSL
– List of nodes whose descendents have not been generated and searched
DE– List of dead end nodes
All lists are treated as stacks CS
– Current state of the search
The Algorithm
State Space
a
b
F
g
c
a
d
h
i
j
A as a child of C is intentional
TraceGoal: J, Start: ANSL SL CS DEA A ABCDA BA BFBCDA FBA FGFBCDA GFBA GFBCDA FBA F FGBCDA BA B BFGCDA A C
CA CDA DA DJDA JDA J(GOAL)
Depth-First: A Simplification of BT
Eliminate saved path Results in Depth-First search
– Goes as deeply as possible– Is not guaranteed to find a shortest path– Maintains two lists
Open List– Contains states generated– Children have not been examined (like NSL)– Open is implemented as a stack
Closed List– Contains states already examined– Union of SL and DE
bool Depth-First(Start){
open = [Start];closed = [];while (!isEmpty.open()){
CS = open.pop();if (CS == goal)
return true; else { generate children of CS; closed.push(CS); eliminate children from CS that are on open or closed;
while (CS has more children) open.push(child of CS);
} } return false;}
State Space
a
b
E
g
c
a
d
h
i
j
A as a child of C is intentional
Goal: JStart: AOpen CS Closed
A [][] A
ABCDCD B
BAECDCD E BA
EBAGCDCD G
GEBAD C[] D
DJHH J(return true)
Breadth-First Search: DF but with a Queue
bool Breadth-First(Start){
open = [Start];closed = [];while (!isEmpty.open()){
CS = open.dequeue();if (CS == goal)
return true; else { generate children of CS; closed.enqueue(CS); eliminate children from CS that are on open or closed;
while (CS has more children) open.enqueue(child of CS);
} } return false;}
Trace
If you trace this, you’ll notice that the algorithm examines each node at each level before descending to another level
You will also notice that open contains:1. Unopened children of current state2. Unopened states at current level
Both Algorithms
1. Open forms frontier of search2. Path can be easily reconstructed
Each node is an ordered pair (x,y) X is the node name Y is the parent When goal is found, search closed for
parent, the parent of the parent, etc., until start is reached.
Breadth-First Finds shortest solution If branching factor is high, could require a
lot of storageDepth-First If it is known that the solution path is long,
DF will not waste time searching shallow states
DF can get lost going too deep and miss a shallow solution
DF and BF follow for the 8-puzzle
8 Puzzle—DF (p. 105)
Depth First Search of 8-Puzzle (p. 105)Depth Bound = 5
Search Protocol: L, U, R, DIf each state has B children on average, requires that we store B * N states to go N levels deep
8 Puzzle-BF (p. 103)Depth Bound = 5
Search Protocol: L,U,R,DIf each state has on average B children, requires that we store B * the number of states
on the previous level for a total of BN states at level N.
Problem with Depth Bounds
What happens if we don’t reach the goal at a given depth bound?
Fail
Solution Depth-first iterative deepening
– Perform DF search, Depth Bound = 1– If fail, Perform DF search, Depth Bound = 2– …– If fail, Perform DF search …
At each iteration, alg. Perform a complete search to the current depth
Guaranteed to find shortest path—because is searches level by level
Attractive properties:– Space usage is B X N where B is the avg number children and N the level– Time complexity how many nodes have to be search worst case: O(BN)– Just like depth-first and depth-first. – Why goes back to the def. of O: (BN + BN-1 + … + 1)
Recommended