Upload
alyssa-childress
View
215
Download
0
Embed Size (px)
Citation preview
Greedy best-first search
• Use the heuristic function to rank the nodes
• Search strategy– Expand node with lowest h-value
• Greedily trying to find the least-cost solution
Greedy Best-First Search
Path search(start, operators, is_goal) { fringe = makeList(start);
while (state=fringe.popFirst()) { if (is_goal(state))
return pathTo(state); S = successors(state, operators);
fringe = insert(S, fringe); }
return NULL;}
Order the nodes in increasing values of h(N)
Procedure Best-First Search
begin
open [Start]
closed [ ]
while open [ ] do begin
remove leftmost state from open and call it X
if X is a goal then return the path from Start to X
else begin
generate children of X
for each child of X do begin
switch
case the child is not on open or closed
assign the child a heuristic value and add the child to open
case the child is already on open if the child was reached by a shorter path then
give the state on open the shorter path
case the child is already on closed if the child was reached by a shorter path then
remove the state from closed and add the child to open
put X on closed
re-order states on open by heuristic merit (best leftmost)
end
end
end
return failure
end
Example
A-5
B-4 C-4 D-6
E-5F-5
G-4 H-3
1. Open = [A5];closed = []
2. Evl A5; open=[B4,C4,D6];closed=[A5]
3. Eval B4;open=[C4,E5,F5,D6]; closed=[B4,A5]
4. Eval C4; open = [H3,G4,E5,F5,D6] ; closed=[C4,B4,A5]
• A search algorithm is admissible if it is guaranteed to find a minimal path to a solution whenever such a path exist.
• f*(n) = g*(n) + h*(n)g*(n) is the cost of the shortest path from
the start node to n.h*(n) is the actual cost of the shortest
path n to the goal.Then f*(n) is the actual cost of the optimal
path from a start node to a goal node that passes through node n.
• f* does not exist.
• Algorithm A– Use f(n) = g(n) + h(n) and best-first-search
algorithm
• Algorithm A*– If h(n) h*(n) in the algorithm A then it is called
Algorithm A*
• Theorem: All A* algorithms are admissible
Implementing Heuristic Evaluations
• For 8-puzzle, two heuristics are …– Counts the tiles out of place in each state when it is compared
with the goal.– Sum all the distances by which the tiles are out of place, one for
each square a tile must be moved to reach its position in the goal state.
2 8 31 47 5
6
left
2 8 31 4
7 56
2 8 31 47 56
2 8 31 47 5
6
Example
h1(S)=7
h2(S)=4+0+3+3+1+0+2+1=14
Comparison of Heuristics applied to states in the 8-puzzle
2 8 31 4
7 56
2 8 31 47 56
2 8 31 47 5
6
5 6
3 4
5 6
Tile out of placeSum of distances out of place
h1 h2
Admissible Heuristic
A* Search
• Greedy best-first search is too greedy– It does not take into account the cost of the
path so far!
• Define– f(n)=g(n)+h(n)– g(n) is the cost of the path to node n– h(n) is the heuristic estimate of the cost of
reaching the goal from node n
• A* search – Expand node in fringe (queue) with lowest f
value
2 8 31 47 5
6
left
2 8 31 4
7 56
2 8 31 47 56
2 8 31 47 5
66 4 6
2 8 31 4
7 56
2 8 31 47 56
28
31 47 56
5 5 6
28 31 4
7 56
2 8 31 47
56
28
31 47 56
5
1
2
3 4
5
A*Another Example
A*
A*
A*
A*
A*
A*
A* Search• Complete: Yes
• Time Complexity: Exponential
- Depends on h(n)
• Space Complexity: Exponential - Keeps all nodes in memory
• Optimal: Yes. If h(n) is an admissible heuristic
• Optimally efficient
How fast is A*?A* is the fastest search algorithm. That is, for any given heuristic, no algorithm can expand fewer nodes than A*.
How fast is it? Depends of the quality of the heuristic.[(relative error in h) x (length of solution)]
Exponential time complexity in worst case. A good heuristic will help a lot here
O(bm) if the heuristic is perfect
•If the heuristic is useless (ie h(n) is hardcoded to equal 0 ), the algorithm degenerates to uniform cost.
•If the heuristic is perfect, there is no real search, we just march down the tree to the goal.
Generally we are somewhere in between the two situations above. The time taken depends on the quality of the heuristic.
Dominance• Given two admissible
heuristics h1(n) and h2(n), which is better?
• If h2(n) h1(n) for all n, then– h2 is said to dominate h1– h2 is better for search
• For our 8-puzzle heuristic, does h2 dominate h1?
A*’s space complexity
Main problem: space complexity
A* has worst case O(bd) space complexity, but an iterative deepening version is possible ( IDA* )