1 Informed Search Idea: be smart about what paths to try.
4
General Tree Search Paradigm(adapted from Chapter 3)
function tree-search(root-node) fringe successors(root-node) while ( notempty(fringe) ) {node remove-first(fringe)
state state(node)if goal-test(state) return solution(node)fringe insert-all(successors(node),fringe) }
return failureend tree-search
Does this look familiar?
5
General Graph Search Paradigm(adapted from Chapter 3)
function graph-search(root-node) closed { } fringe successors(root-node) while ( notempty(fringe) ) {node remove-first(fringe)
state state(node)if goal-test(state) return solution(node)if notin(state,closed)
{add(state,closed)fringe insert-all(successors(node),fringe) }}
return failureend graph-search
What’s the difference between this and tree-search?
7
Best-First Search
• Use an evaluation function f(n).
• Always choose the node from fringe that has the lowest f value.
3 5 1
9
Old Friends
• Breadth first = best first– with f(n) = depth(n)
• Dijkstra’s Algorithm = best first– with f(n) = g(n)– where g(n) = sum of edge costs from start to n– space bound (stores all generated nodes)
10
Heuristics
• What is a heuristic?
• What are some examples of heuristics we use?
• We’ll call the heuristic function h(n).
11
Greedy Best-First Search
• f(n) = h(n)
• What does that mean?
• Is greedy search optimal?
• Is it complete?
• What is its worst-case complexity for a tree with branching factor b and maximum depth m?
12
A* Search• Hart, Nilsson & Rafael 1968
– Best first search with f(n) = g(n) + h(n)
where g(n) = sum of edge costs from start to n
and h(n) = estimate of lowest cost path n-->goal– If h(n) is admissible then search will find optimal
solution.Never overestimates the truecost of any solution which can be reached from a node.{
Space bound since the queue must be maintained.
20
8 Puzzle Example
• f(n) = g(n) + h(n)
• What is the usual g(n)?
• two well-known h(n)’s– h1 = the number of misplaced tiles– h2 = the sum of the distances of the tiles from
their goal positions, using city block distance, which is the sum of the horizontal and vertical distances
21
8 Puzzle Using Number of Misplaced Tiles
2 8 33 6 47 5
1 2 38 47 6 5
goal
2 8 33 47 6 5
2 8 33 6 4 7 5
2 8 33 6 47 5
2 33 8 47 6 5
2 8 33 47 6 5
2 8 3 1 47 6 5
0+4=4
5+1=6 4 6
1st
2nd
5 5 6
23
Optimality of A*Suppose a suboptimal goal G2 has been generated and is in the queue. Let n be an unexpanded node on the shortest path to an optimal goal G1.
G1
n
G2
f(n) = g(n) + h(n) < g(G1) Why? < g(G2) G2 is suboptimal = f(G2) f(G2) = g(G2)
So f(n) < f(G2) and A* will never selectG2 for expansion.
24
Algorithms for A*
• Since Nillsson defined A* search, many different authors have suggested algorithms.
• Using Tree-Search, the optimality argument holds, but you search too many states.
• Using Graph-Search, it can break down, because an optimal path to a repeated state can be discarded if it is not the first one found.
• One way to solve the problem is that whenever you come to a repeated node, discard the longer path to it.
25
The Rich/Knight Implementation
• a node consists of– state– g, h, f values– list of successors– pointer to parent
• OPEN is the list of nodes that have been generated and had h applied, but not expanded and can be implemented as a priority queue.
• CLOSED is the list of nodes that have already been expanded.
26
Rich/Knight
1) /* Initialization */
OPEN <- start node
Initialize the start node
g:
h:
f:
CLOSED <- empty list
27
Rich/Knight
2) repeat until goal (or time limit or space limit)
• if OPEN is empty, fail• BESTNODE <- node on OPEN with lowest f• if BESTNODE is a goal, exit and succeed• remove BESTNODE from OPEN and add it to
CLOSED• generate successors of BESTNODE
28
Rich/Knight
for each successor s do1. set its parent field2. compute g(s)3. if there is a node OLD on OPEN with the same state info as s
{ add OLD to successors(BESTNODE)
if g(s) < g(OLD), update OLD and throw out s }
29
Rich/Knight4. if (s is not on OPEN and there is a node
OLD on CLOSED with the same state info as s
{ add OLD to successors(BESTNODE)
if g(s) < g(OLD), update OLD,
throw out s,
***propagate the lower costs to successors(OLD) }
That sounds like a LOT of work. What could we do instead?
30
Rich/Knight
5. If s was not on OPEN or CLOSED
{ add s to OPEN
add s to successors(BESTNODE)
calculate g(s), h(s), f(s) }
end of repeat loop
31
The Heuristic Function h
• If h is a perfect estimator of the true cost then A* will always pick the correct successor with no search.
• If h is admissible, A* with TREE-SEARCH is guaranteed to give the optimal solution.
• If h is consistent, too, then GRAPH-SEARCH without extra stuff is optimal.
h(n) < c(n,a,n’) + h(n’) for every node n and each of its successors n’ arrived at through action a.
• If h is not admissable, no guarantees, but it can work
well if h is not often greater than the true cost.