Problem Solving Using Search

1. Problem Solving Using Search Brute-force search Heuristic search Competitive search

2. Search Search cont. Many problems can only be solved by searching

3. Search Importance of efficient search algorithms • Tic tac toe • state space of 9!: • 9 possible first moves, followed by 8 possible second moves, followed by 7 possible third moves, etc., or 9x8x7x…x1 moves or 9! • Can use exhaustive search • Chess • 10120 possible paths • can’t use exhaustive search

4. Search State Space Search • use a state space graph to represent the problem • each node represents a partial solution state • each arc represents transition between states • can be directed or undirected • tree - a graph in which 2 nodes have at most one path between them (no loops or cycles) • state space search - find a solution path from the start state to a goal state

5. Search traveling salesperson • Fig 3.7 • O(N!) ; actually (N-1)!

6. Search Tree-based search • tree representation is often used to search for a path from the initial state to the goal state (Ex: eights puzzle) • number of possible states: 9!

7. Search Eights puzzle state tree

8. Search Graph search vs tree search • General graph search algorithm must detect and eliminate loops; this is done by ensuring that a state is only examined once • trees don’t need to do this because they don’t have loops

9. Search Unguided (blind) search • does not use heuristic information during the search process • depth first search examines all descendants of a node before the nodes at the same level are examined • breadth-first search examines all nodes at a given level before the nodes of the descendants

10. Search Unguided (blind) search cont. • Breadth first algorithm: 1. create a queue and add the first node to it 2. Loop: If the queue is empty, quit. Remove the first node from the queue. If the node contains the goal state, exit with the node as the solution. For each child of the current node: Add the new state (no duplicates) to the back of the queue.

11. Search Breadth-first search QUEUE: A BC CDE DEFG EFGHI FGHIJK GHIJKLM HIJKLMNO IJKLMNO JKLMNO KLMNO LMNO • ABCDEFGHIJKL

12. Search Unguided (blind) search cont. • depth first algorithm: 1. create a queue and add the first node to it 2. Loop: If the queue is empty, quit. Remove the first node from the queue. If the node contains the goal state, exit with the node as the solution. For each child of the current node: Add the new state (no duplicates) to the front of the queue.

13. Search Depth-first search QUEUE: A BC DEC HIEC IEC EC JKC KC C FG LMG ... • ABDHIEJKCFL

14. Search Breadth first vs depth first • Breadth first • guaranteed to find the shortest path • space inefficient • all unexpanded nodes for each level are kept in the queue • if average branching factor is B, have Bn states on level n (root is level 0) • if solution path is long or B is large, memory requirements large • depth first • not guaranteed to find shortest path • space efficient • at each level, keeps only the children of a single node in the queue (B*n) states at level n

15. Search Unguided (blind) search cont. • Depth-first search with iterative deepening • perform depth-first search up to a maxDepth • control loop continually deepens depth-first search • more efficient than breadth-first and depth-first on large search spaces Russell and Norvig 1995 • time behavior is the same as depth-first and breadth-first search: O(Bn) • Note: all unguided search techniques have worst case exponential time behavior

16. Search Using state space to represent reasoning with predicate calculus • Use and/or graphs to represent implications of the form pqr

17. Search • Two methods of searching graph: • data-driven: find path from known true facts to goal • goal directed: start with the proposition to be proved (the goal) and search backwards along arcs to find support for the goal among the true propositions

18. Search • Examples: • p. 110, fig 3.21 • p. 112, fig 3.23 • financial advisor fig 3.24 • sentence parser p. 116, fig 3.25

19. Search Guided (heuristic) search • uses additional information, often in the form of estimates, to guide the search

20. Search Guided (heuristic) search cont. • hill-climbing • each node has an associated value or cost; move to the node with the highest value (or lowest cost) • uses no memory and backtracking • can only find local maximum (minimum)

21. Search Ex: Traveling Salesperson • Fig. 3.9

22. Search Guided (heuristic) search cont. • Best-first algorithm: 1. create a queue and add the first node to it 2. Loop: If the queue is empty, quit. Remove the first node from the queue. If the node contains the goal state, exit with the node as the solution. For each child of the current node: if the child has not yet been visited or the child is reached by a path of lower cost than when visited previously, add the child node to the queue, in order of cost, eliminating any other higher cost paths to this child

23. Search Guided (heuristic) search cont • Heuristic evaluation function may be the sum of two components: • f(n) = g(n) + h(n) • g(n) measures cost from the start state to state n • h(n) estimates cost from state n to goal state

24. Search Guided (heuristic) search cont • for the eight puzzle, • g(n) = the number of moves from start to the current state. • H1(n) = the number of tiles that are out of place; • H2(n) = the sum of the Manhattan distances (horizontal and vertical distances) for the tiles that are out of place

25. Search Guided (heuristic) search cont. • A* search use evaluation function f(n)=g(n)+h(n) where h(n) <=h*(n) //h*(n) is actual minimum cost from n to goal

26. Search Shortest path problem • Find the shortest path from a start node to a goal node • must keep track of paths and costs of paths • reject paths with loops • for the shortest path problem, g(n) is the total distance between the initial state and the state n, and h(n) is the estimated distance from state n to the goal state • A* also eliminates the more costly of redundant paths

27. Search Shortest path problem cont. • A* shortest path algorithm 1. create a queue and add the first node to it as a zero-length path. 2. Loop: • If the queue is empty, quit and announce failure. • Remove the first path from the queue. If it ends at the goal state, exit with this path as the solution. Otherwise, create new paths by extending the first path to all the neighbors of the terminal node. • Reject all new paths with loops. • If two or more paths reach a common node, delete all those paths except the one that reaches the common node with the minimum cost. • Sort the entire queue by the sum of the path length and a lower bound estimate of the cost remaining, with least-cost paths in front.

28. Search Example: TSP

29. Search Ex: robot path planning • P. 94-99, Winston 3rd Edition

30. Search Competitive (Game) Search • Used for competitive games • uses a move generator, a position evaluator and a look-ahead strategy • game states are represented as a tree • initial state is the root • the player (computer) is the maximizer, and the opponent is the minimizer; 'minimax' search

31. Search 'minimax' search cont. • example: tic-tac-toe • evaluation function measures the number of rows/columns/diagonals open to the player versus the opponent: E(s) = H(s) = (rX + cX + dX) - (ro + co + do)

32. Search 'minimax' search cont. • alpha beta pruning prunes branches which are not needed • lower bound alpha is the largest current value of all the MAX ancestors of the node • upper bound beta is the smallest current value of all its MIN ancestors • X tries to maximize alpha at each MAX level; O tries to minimize beta at each MIN level

33. Search Summary • Search methods • unguided • depth first, breadth first • guided • hill climbing • best first • A* • competitive • minimax