20070315 chap3 1

**Chapter3**

**Solving Problems by Searching**

**Problem-Solving Agents**

**• Reflex agents cannot work well in those environments**
**- state/action mapping too large**

**- take too long to learn**

**• Problem-solving agent**

**- is one kind of goal-based agent**

**- decides what to do by finding sequences of actions **
**that lead to desirable states**

20070315 chap3 3

**Problem Solving Agents **

^{(cont.)}**• Formulation **

**- Goal formulation ****(final state)**

**- Problem formulation ****(decide what actions and states to consider)**

**• Search ****(look for solution i.e.action sequence) **

**• Execution ****(follow states in solution)**

**Assume the environment is****static, observable, discrete, deterministic**

20070315 chap3 4

**Well-defined Problems and Solutions**

• **A problemcan be defined by**

**- Initial state **^{In(Arad)}

**- Possible actions (or successor function) **

**{<Go(Sibiu), In(Sibiu)>, <Go(Timi), In(Timi)>, <Go(Zerind), In(Zerind)>}**

**- Goal test ****{In(Bucharest)}**

**- Path cost function **

• **Step cost: ****c(x, a, y)**

**taking action a to go from state x to state y**

• **Optimal solution**

**the lowest path cost among all solutions**

* state space*of a problem

20070315 chap3 5

**Example: Romania**

**Example Problems**

• **Toy problems**

**Vacuum World, 8-Puzzle, 8-Queens Problem, **
**Cryptarithmetic, Missionaries and Cannibals**

• **Real-world problems**

**Route finding, Touring problems**
**Traveling salesman problem,**
**VLSI layout, Robot navigation,**
**Assembly sequencing,**

**Protein Design, Internet Searching**

20070315 chap3 7

**Vacuum World**

20070315 chap3 8

**Vacuum World **

**(cont.)**• **States: **

**agent location, each location might or **
**might not contain dirt**

**# of possible states = 2* 2 **^{2 }**= 8 **

• **Initial state: ****any possible state**

• **Successor function: ****possible actions (left, Right, Suck)**

• **Goal test: ****check whether all the squares are clean**

• **Path cost:****the number of steps, each step cost 1**

20070315 chap3 9

**The 8-Puzzle**

**• States: ****location of each of the eight tiles and the blank tile**

**# of possible states = 9!/2 = 181,440 --- 9!/4 ???**

**• Initial state: ****any state**

**• Successor function: ****blank moves(left, Right, Up, Down)**

**• Goal test: ****check whether the state match as the goal configuration**

**• Path cost:****the number of steps, each step cost 1**

**The 8-Queens**

•**Incremental formulation vs. **

**complete-state****formulation**

•**States-I-1: 0-8 queens on board **

**• Successor function-I-1: **

**add a queen to any square**

**# of possible states = (64*63*…*57=** **)**

**• States-I-2: 0-8 non-attacking queens on board **

**• Successor function-I-2: **

**add a queen to a non-attacking square in the left-most **
**empty column**

**# of possible states = 2057 --- ???**

**• Goal test: 8 queens on board, none attacked**

**• Path cost:****of no interest (since only the final state count)**
1014

* 3

20070315 chap3 11

**Robotic Assembly**

**• States: ****real-valued coordinates of robot joint angles **
**parts of the object to be assembled**

**• Successor function: ****continuous motions of robot joints**

**• Goal test : ****complete assembly **

**• Path cost : ****time to execute**

20070315 chap3 12

**Basic Search Algorithms**

• **How do we find the solutions of previous **
**problems?**

- **Search the state space (remember complexity of space **
**depends on state representation)**

- **Here: search through explicit****tree****generation**
**ROOT= initial state.**

**Nodes and leafs generated through successor function****.**
- **In general search generates a graph****(same state through **

**multiple paths)**

20070315 chap3 13

**Tree Search Algorithms**

**Simple Tree Search Example**

**function TREE-SEARCH(problem, strategy) return a solution or failure****Initialize search tree to the initial state of the problem**

loop do

**if no candidates for expansion then return failure****choose leaf node for expansion according to strategy****if node contains goal state then return solution**

**else expand the node and add resulting nodes to the search tree**
end

20070315 chap3 15

**Simple tree search example**

**function TREE-SEARCH(problem, strategy) return a solution or failure****Initialize search tree to the initial state of the problem**

loop do

**if no candidates for expansion then return failure****choose leaf node for expansion according to strategy****if node contains goal state then return solution**

**else expand the node and add resulting nodes to the search tree**
end

20070315 chap3 16

**Simple tree search example**

**function TREE-SEARCH(problem, strategy) return a solution or failure****Initialize search tree to the initial state of the problem**

loop do

**if no candidates for expansion then return failure****choose leaf node for expansion according to strategy****if node contains goal state then return solution**

**else expand the node and add resulting nodes to the search tree**
end

**← Determines search process!!**

20070315 chap3 17

**State Space vs. Search Tree**

• **State: a (representation of) a physical configuration**

• **Node: a data structure belong to a search tree**

**< State, Parent-Node, Action, Path-Cost, Depth>**

• **Fringe: contains generated nodes which are not yet **
**expanded.**

**General Tree-Search Algorithm**

20070315 chap3 19

**Search Strategies**

•**A strategy is defined by****picking the order of node expansion**

•**Strategies are evaluated along**

-**Completeness****---****Is it guaranteed that a solution will be found (if one exists)? **

-**Time complexity****--- How long does it take to find a solution? **

-**Space complexity****--- How much memory is needed to perform a search? **

-**Optimality****--- Is the best solution found when several solutions exist?**

•**Time and space complexity are measured in terms of **

**b --- maximum branching factor of the search tree****d --- depth of the least-cost solution**

**m --- maximum depth of the state space (may be ∞)**

20070315 chap3 20

**Uninformed Search Strategies**

**• Breadth-first search **

**-Tree-Search( problem, FIFO-Queue() )****- Expand the shallowest****node in the fringe. **

**- It is both optimal and complete. **

**• Uniform-cost search**

**• Depth-first search**

**- Expand the deepest node in the fringe. **

**- It is neither complete nor optimal. Why? **

**• Depth-limited search**

**• Iterative deepening search **

**- Try all possible depth limits in depth limited search. **

**- It is both optimal and complete. **

**use only the information available in the problem definition**

**do not use state information to decide the order on which nodes are expanded**

20070315 chap3 21

**Breadth-First Search**

• *Tree-Search(problem, FIFO-Queue())*

*• Fringe is a FIFO queue, i.e., new successors go at end*

• Expand the shallowestunexpanded node

**Analysis of Breadth-First Search**

**Complete??** **Yes (if b is finite)**

**Time??**

**expand all but the last node at level d i.e. exp. in d**

**Space??**

**keep every node in memory**

**Optimal??****Yes (if cost = 1 per step); **

**not optimal in general (unless actions have different cost)**

) ( ) (

1+*b*+*b*^{2}+L+*b** ^{d}* +

*b*

^{d}^{+}

^{1}−

*b*=

*O*

*b*

^{d}^{+}

^{1}

)
(*b*^{d}^{+}^{1}
*O*

20070315 chap3 23

**Analysis of Breadth-First Search **

^{(cont.)}• **Space****is the bigger problem (more than time)**
**If d = 8, it will take 31 hours with 1 terabytes.**

• **Exponential complexity search problems cannot be solved by **
**uninformed search methods for any but the smallest instances.**

**1 exabyte**
**3523 years**

**10**^{15}**14**

**10 petabytes**
**35 years**

**10**^{13}**12**

**101 terabytes**
**129 days**

**10**^{11}**10**

**1 terabyte**
**31 hours**

**10**^{9}**8**

**10 gigabytes**
**19 minutes**

**10**^{7}**6**

**106 megabytes**
**11 seconds**

**111100**
**4**

**1 megabyte**
**0.11 **

**seconds**
**1100**

**2**

MEMORY TIME

NODES DEPTH

20070315 chap3 24

**Uniform Cost Search**

**• Each node n has a path cost g(n). **

**• Expand lowest path costunexpanded node.**

**• Fringe is queue ordered by path cost.**

**• It will find the cheapestsolution provided that**

**i.e. Every operator has a nonnegative cost. **

**• Equivalent to breadth-first searchif step costs all equal.**

) ( )) ( (

.*g* *Successor* *n* *g* *n*

*n* ≥

∀

20070315 chap3 25

**Uniform Cost Search**

^{(cont.)}**Analysis of Uniform Cost Search**

**Complete??** **Yes (if step cost >= ε)**
**Time??**

**Where C**^{*}**is the cost of the optimal solution**
**Space??**

**Optimal??****Nodes expanded in increasing order of g(n)****Yes, if complete**

⎡ ⎤)
(*b*^{C}^{*}^{/}^{ε}
*O*

⎡ ⎤)
(*b*^{C}^{*}^{/}^{ε}
*O*

20070315 chap3 27

**Depth-First Search**

• **Tree-Search(problem, LIFO-Queue())**

**• Fringe is a LIFO queue, **

**i.e., stack, put successors at front.**

**• Expand the deepest unexpanded node **

20070315 chap3 28

**Depth-First Search **

**(cont.-1)**• **Tree-Search(problem, LIFO-Queue())**

**• Fringe is a LIFO queue, **

**i.e., stack, put successors at front.**

**• Expand the deepest unexpanded node **

20070315 chap3 29

**Depth-First Search **

^{(cont.-2)}• **Tree-Search(problem, LIFO-Queue())**

**• Fringe is a LIFO queue, **

**i.e., stack, put successors at front.**

**• Expand the deepest unexpanded node **

**Depth-First Search **

**(cont.-3)**• **Tree-Search(problem, LIFO-Queue())**

**• Fringe is a LIFO queue, **

**i.e., stack, put successors at front.**

**• Expand the deepest unexpanded node **

20070315 chap3 31

**Depth-First Search **

^{(cont.-4)}• **Tree-Search(problem, LIFO-Queue())**

**• Fringe is a LIFO queue, **

**i.e., stack, put successors at front.**

**• Expand the deepest unexpanded node **

20070315 chap3 32

**Depth-First Search **

**(cont.-5)**• **Tree-Search(problem, LIFO-Queue())**

**• Fringe is a LIFO queue, **

**i.e., stack, put successors at front.**

**• Expand the deepest unexpanded node **

20070315 chap3 33

**Depth-First Search **

^{(cont.-6)}• **Tree-Search(problem, LIFO-Queue())**

**• Fringe is a LIFO queue, **

**i.e., stack, put successors at front.**

**• Expand the deepest unexpanded node **

**Depth-First Search **

**(cont.-7)**• **Tree-Search(problem, LIFO-Queue())**

**• Fringe is a LIFO queue, **

**i.e., stack, put successors at front.**

**• Expand the deepest unexpanded node **

20070315 chap3 35

**Depth-First Search **

^{(cont.-8)}• **Tree-Search(problem, LIFO-Queue())**

**• Fringe is a LIFO queue, **

**i.e., stack, put successors at front.**

**• Expand the deepest unexpanded node **

20070315 chap3 36

**Depth-First Search **

**(cont.-9)**• **Tree-Search(problem, LIFO-Queue())**

**• Fringe is a LIFO queue, **

**i.e., stack, put successors at front.**

**• Expand the deepest unexpanded node **

20070315 chap3 37

**Depth-First Search **

^{(cont.-10)}• **Tree-Search(problem, LIFO-Queue())**

**• Fringe is a LIFO queue, **

**i.e., stack, put successors at front.**

**• Expand the deepest unexpanded node **

**Depth-First Search **

**(cont.-11)**• **Tree-Search(problem, LIFO-Queue())**

**• Fringe is a LIFO queue, **

**i.e., stack, put successors at front.**

**• Expand the deepest unexpanded node **

20070315 chap3 39

**Analysis of Depth-First Search**

**Complete??**

**No: fails in indefinite-depth spaces, spaces with loops**
**Modify to avoid repeated states along path**

**⇒ Complete in finite spaces**

**Time??** **: terrible if m is much larger than d****(m: the maximum depth of any node, **

**d: depth of the shallowest solution)**

**But if solutions are dense, may be much faster than breadth-first**

**Space??** **O(bm), ****i.e., linear space**

**Optimal??No**

**If d = 12, b= 10, **

**Space: 10 petabytes for BFS; 118 KB for DFS**

)
(*b*^{m}*O*

20070315 chap3 40

**Analysis of Depth-First Search **

^{(cont.)}**• Time requirement: **

**- Goal at the far left: d+1 ****- Goal at the far right: **

**- Average: (How is the average derived?) **

) 1 ( 2

1 2

−

−

− +

+ +
*b*

*d*
*b*
*bd*
*b*^{d}

1

1 1

−

+ −
*b*
*b*^{d}

20070315 chap3 41

**Depth-limited Search**

**The unbounded trees can be alleviated by supplying depth-first **
**search with a predetermined depth limit l.**

**Failure (no solution) / Cutoff (no solution within the depth limit)**

**Analysis of Depth-Limit Search**

**Complete??Yes, ****if l >= d**

**if l <=d , the shallowest goal is beyond the depth limit.**

**Time??**

**Space??** **O(bl)****Optimal??No**

**DFS can be viewed as **

* a special case of depth-limit search with l = *∞

**Diameterof state space is a better depth limit,**

**which leads to a more efficient depth-limit search**
)

(

2 ...

1

0 *l* *l*

*b*
*O*
*b*
*b*

*b*

*b* + + + + =

20070315 chap3 43

**Iterative Deepening Search**

20070315 chap3 44

**Iterative Deepening Search **

^{(cont.-1)}20070315 chap3 45

**Iterative Deepening Search **

^{(cont.-2)}**Iterative Deepening Search **

^{(cont.-3)}20070315 chap3 47

**Iterative Deepening Search **

^{(cont.-4)}20070315 chap3 48

**Analysis of Iterative Deepening Search**

**Complete??** **Yes.**

**Time??**

**Space??** **O(bd)**

**Optimal??Yes, if step cost = 1**

**Can be modified to explore uniform-cost tree.**

**If b = 10, d = 5,**

**Iterative deepening is faster****than breadth-first search,**
**despite the repeated generation of states.**

**Overhead = ****(123,456 - 111,111)/111,111 = 11%**

**Iterative deepening is the preferred uninformed search **

**when there is a large search space and the depth of the solution is **
**not known.**

) ( ...

) 1 ( )

1

(*d*+ *b*^{0}+*db*^{1}+ *d*− *b*^{2}+ +*b** ^{d}* =

*O*

*b*

^{d}**N****BFS****= 1 + 10 + 100 + 1,000 + 10,000 + 999,990 = 1,111,101**
**N**_{DLS}**= 1 + 10 + 100 +1,000 + 10,000 + 100,000 = 111,111**
**N****IDS****= 6 + 50 + 400 + 3,000 + 20,000 + 100,000 = 123,456**

20070315 chap3 49

**Bidirectional Search**

**• Search forward from the initial state.**

**Generate successors to the current node.**

**• Search backward from the goal.**

**Generate predecessors to the current node.**

**• Stop when two searches meet in the middle.**

**Bidirectional Search**

^{(cont.-1)}• **Two simultaneous searches from start an goal.**

- **Motivation: **

• **Check whether the node belongs to the other fringe before expansion.**

• **Space complexity is the most significant weakness.**

• **Complete and optimal if both searches are BF.**

*b*^{d / 2}*+ b*^{d / 2}*≠ b*^{d}

20070315 chap3 51

**Bidirectional Search**

^{(cont.-2)}**Issues:**

**• If all operators are reversible,**
**predecessor(n) = successor(n)**

**• Multiple goal states**

**• Cost of checking if a node exists**

**• Search strategy for each half ? **

20070315 chap3 52

**Comparing Uninformed Search ** **Strategies**

**• b: the branching factor **

**• d: the depth of the shallowest solution **

**• m: the maximum depth of the search tree **

**• l: the depth limit **

20070315 chap3 53

**Comparing Uninformed Search ** **Strategies **

^{(cont.)}**Issues considered in selecting search strategies: **

**• size of the search space **

**• depth of the solution **

**• solution density **

**• finite vs. infinite depth **

**• any vs. all solutions **

**• optimality? **

**• predecessors? **

**Avoid Repeated States**

**• Do not return to the previous state. **

**• Do not create paths with cycles. **

**• Do not generate the same state twice. **

**- Store states in a hash table. **

20070315 chap3 55

**Graph Search**

**• To modify “Tree Search Algorithm” by adding**
**closed list--- to store every expanded node**