State Space Search

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 • Pursue path until goal is reached or dead end • If goal, quit and return the path • 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 d b c h j a F i g A as a child of C is intentional

Trace Goal: J, Start: A NSL SL CS DE A A A BCDA BA B FBCDA FBA F GFBCDA GFBA G FBCDA FBA F FG BCDA BA B BFG CDA A C CA C DA DA D JDA 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 d b c h j a E i g A as a child of C is intentional

Goal: J Start: A Open CS Closed A [] [] A A BCD CD B BA ECD CD E BA EBA GCD CD G GEBA D C [] D D JH H 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: • Unopened children of current state • Unopened states at current level

Both Algorithms • Open forms frontier of search • 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

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—DF (p. 105)

8 Puzzle-BF (p. 103)Depth Bound = 5Search 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)

State Space Search