1 / 22

UnInformed Search

Learn how to tackle problems when you're clueless by grasping algorithm basics, properties, and complexities. Dive into search algorithms, state-space assumptions, and derived methods. Understand depth-first, breadth-first, uniform cost, and more with detailed examples. This informative guide delves into algorithm variation, memory usage, and strategies for optimal solutions. Enhance your search skills and conquer any challenge confidently.

charleslwilliams
Download Presentation

UnInformed Search

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. UnInformed Search What to do when you don’t know anything

  2. What to know • Be able to execute (by hand) an algorithm for a problem • Know the general properties • Know the advantages/disadvantages • Know the pseudo-code • Believe you can code it

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

  4. 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

  5. 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

  6. Derived Search Algorithms • Algorithm description incomplete • What is “store in memory” • What is “memory” • What is “select” • Different choices yield different methods.

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

  8. 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.

  9. 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)

  10. Breadth First • 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.

  11. 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.

  12. 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.

  13. 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.

  14. 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

  15. 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.

  16. 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

  17. 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

  18. 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.

  19. 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)

  20. 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

  21. Algorithm Effects • Cycles: • DFS incomplete: fix cycle checking • IDS incomplete: fix cycle checking • BFS still complete, but increased cost

  22. Grid World • Start (0,0) • Goal (8,8) • Legal moves: up, down, left, right • What happens to algorithms?

More Related