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 path 3. 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

Trace Goal: J, Start: A NSLSLCSDE AAA BCDABAB FBCDAFBAF GFBCDAGFBAG FBCDAFBAFFG BCDABABBFG CDAAC CAC DADAD JDAJDAJ(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; return true; else else { generate children of CS; generate children of CS; closed.push(CS); closed.push(CS); eliminate children from CS that are on open or closed; eliminate children from CS that are on open or closed; while (CS has more children) open.push(child of CS); open.push(child of CS); } } return false; return false;}

State Space a b E g c a d h i j A as a child of C is intentional

Goal: J Start: A OpenCSClosed A[] []A A BCD CDB BAECD CDEBA EBAGCD CDG GEBA DC []D DJH HJ(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; return true; else else { generate children of CS; generate children of CS; closed.enqueue(CS); closed.enqueue(CS); eliminate children from CS that are on open or closed; eliminate children from CS that are on open or closed; while (CS has more children) open.enqueue(child of CS); open.enqueue(child of CS); } } return false; 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 state 2. Unopened states at current level

Both Algorithms 1. Open forms frontier of search 2. 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 storage Depth-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, D If 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,D If each state has on average B children, requires that we store B * the number of states on the previous level for a total of B N states at level N.

Problem with Depth Bounds  What happens if we don’t reach the goal at a given depth bound?  Fail

Solution