# PowerPoint Presentation

Shared by:
Categories
Tags
-
Stats
views:
0
posted:
9/11/2012
language:
English
pages:
22
Document Sample

```							  UnInformed Search

What to do when you don’t know
anything
What to know
• Be able to execute (by hand) an algorithm
for a problem
• Know the general properties
• Know the pseudo-code
• Believe you can code it
Assumptions of State-Space Model

•   Fixed number of operators
•   Finite number of operators
•   Known initial state
•   Known behavior of operators
•   Perfect Information
•   Real World  Micro World
•   What we can do.
Concerns
• State-space: tree vs graph?
– Are states repeated?
•   Completeness: finds a solution if one exists
•   Time Complexity
•   Space Complexity: Major problem
•   Optimality: finds best solution
•   Assume Directed Acyclic graphs (DAGS)
– no cycles
• Later: adding knowledge
General Search Algorithm
• Current State = initial state
• While (Current State is not the Goal)
– Expand State
• compute all successors/ apply all operators
– Store successors in Memory
– Select a next State
– Set Current state to next
• If current state is goal: success, else failure
Derived Search Algorithms
•   Algorithm description incomplete
•   What is “store in memory”
•   What is “memory”
•   What is “select”
•   Different choices yield different methods.
Abstract tree for evaluation
• Let T be a tree where each node has b
descendants. B is the branching factor.
• Suppose that a goal lies at depth d.
• If goal is root, depth of solution is 0.
• Unlike in theory, tree usually generated
dynamically.
Depth First
• Storage = Stack
• Add = push
• Select = Pop
• Not complete (if infinite or cycles,
otherwise complete)
• Not optimal
• Time: O(b^m), space O(bm) where m is
max depth.
Ex. DFS for Permutations of 3
•   Initial State: <->
•   Next State: add to front, no repeats
•   Stack: { <->}
•   Next Stack: { <1>,<2>,<3>}
•   Next Stack: < <1,2>, <1,3>, <2>, <3>} etc
•   Trick: encode states with legal operators
– <->  <-,{1,2,3}>
• How much memory? O(n^2)
•   Memory = Queue
•   Store = add to end
•   Select = take from the front
•   Properties:
– complete,
– optimal: min of steps
• Time/Space Complexity =
– 1+b+b^2…+b^d = [b^(d+1) -1 ]/ (b-1) = O(b^d)
• Problem: Exponential memory Size.
Ex. BFS for Permutations of 3
•   Init: <->
•   Queue: { <->}
•   Next Queue { <1>, <2>, <3>}
•   Next Queue { <2>,<3>, <1,2>, <1,3>}
•   So what’s the big deal?
•   Space n!*n for n! search.
Uniform Cost
• Now assume edges have positive cost
• Storage = Priority Queue: scored by path cost
– or sorted list with lowest values first
• Select- choose minimum cost
• add – maintains order
• Check: careful – only check minimum cost for
goal
• Complete & optimal
• Time & space like Breadth.
Uniform Cost Example
• Root – A cost 1
• Root – B cost 3
• A -- C cost 4
• B – C cost 1
• C is goal state.
• Why is Uniform cost optimal?
– Expanded does not mean checked node.
Watch the queue
• R/0 // Path/path-cost
• R-A/1, R-B/3
• R-B/3, R-A-C/5:
– Note: you don’t test expanded node
– You put it in the queue
• R-B-C/4, R-A-C/5
Depth Limited
• Depth First search with limit = l
• Algorithm change: states not expanded if at
depth k.
• Complete : no
• Time: O(b^k)
• Space: O(b*l)
• Complete if solution <=l, but not optimal.
Iterative Deepening
• Set l = 0
• Repeat
– Do depth limited search to depth l
– l = l+1
•   Until solution is found.
•   Complete & Optimal
•   Time: O(b^d)
•   Space: O(bd) when goal at depth d
Comparison Breadth vs ID
• Branching Factor 10
• Depth       Breadth   ID
0         1         1
1        11        12
2        111       123
3        1111      1234
4        11111      12345
Bidirectional
• Won’t work with most goal predicates
• Needs identifiable goal states
• Needs reversible operators.
• Needs a good hashing functions to
determine if states are the same.
• Then: O(b^d/2) time if bf is b in both
directions.
Bidirectional Search

• Simple Case:
• Initial State = {Start State+ Goal State}
• Operators:
– forward from start, backwards from goal
• Standard: Breadth in both directions
• Check: newly generated states intersect
fringe. (can be expensive)
Repeated States
• Occurs whenever reversible operators
• Occurs in many problems
• Improvements
– Do not return to k recent states:
• cheap and non-effective
– Do not return to state on path:
• cycle checking: Cheap and effective
– Do not return to any seen state: exponential
• Memory costs increase for all algorithms
Algorithm Effects

• Cycles:
– DFS incomplete: fix cycle checking
– IDS incomplete: fix cycle checking
– BFS still complete, but increased cost
Grid World
•   Start (0,0)
•   Goal (8,8)
•   Legal moves: up, down, left, right
•   What happens to algorithms?

```
Related docs
Other docs by HC120911162345
PHYSICS � YEAR 11 �EXAMS PAPERS
LOWER MERION FIRE DEPARTMENT SOP #9