|
|
|
Recursive Best-First Search |
|
|
|
|
|
Recall: |
|
Best-First Search with f(n) = g(n) + h(n) is A* |
|
A* finds optimal solution if h(n) never
overestimates |
|
A*’s serious limitation: memory requirement
(often exponential) |
|
A*’s second limitation: keeping candidate nodes
sorted (O(log N) per node, N number of nodes) |
|
|
|
|
A series of depth-first searches bounded by
iteratively increasing f limit. |
|
If f is monotonic (f(child) >= f(parent)),
then IDA* expands nodes in best-first order. |
|
IDA* space requirement – O(bd) |
|
IDA* node generation- O(1) |
|
|
|
|
|
IDASTAR (node : N, bound : B) |
|
IF N is a goal, EXIT algorithm |
|
IF N has no children, RETURN infinity |
|
FN = infinity |
|
FOR each child Ni of N, F[i] := f(Ni) |
|
IF f(Ni) <= B, FN := MIN(FN, IDASTAR(Ni,B)) |
|
ELSE FN := MIN(FN, f(Ni)) |
|
RETURN FN |
|
|
|
|
IDASTARSEARCH (node : N) |
|
B := f(N); |
|
WHILE (TRUE) |
|
B := IDASTAR(N, B) |
|
|
|
|
If f is not monotonic, IDA* no longer expands
nodes in best-first order |
|
When searching nodes with f-values less than
current threshold, search procedes depth-first. |
|
f-values of such nodes are ignored in search
ordering |
|
Example: Fig. 2 tree fragment |
|
Other major limitation: many distinctive
f-values à much re-expansion |
|
|
|
|
|
Recursive best-first search (RBFS): |
|
O(bd)-space algorithm |
|
Expands best-first even without monotonic cost
function |
|
Generates fewer nodes than iterative deepening
with a monotonic cost function |
|
|
|
|
|
Simple RBFS (SRBFS) |
|
Local cost threshold for each recursive call |
|
Has inefficiencies to be addressed in RBFS, but
good intro for teaching purposes |
|
Work the following algorithms with binary tree
where f(n) = depth(n) |
|
|
|
|
|
SRBFS (node : N, bound : B) |
|
IF f(N)>B, RETURN f(N) |
|
IF N is a goal, EXIT algorithm |
|
IF N has no children, RETURN infinity |
|
FOR each child Ni of N, F[i] := f(Ni) |
|
sort Ni and F[i] in increasing order of F[i] |
|
IF only one child, F[2] := infinity |
|
WHILE (F[1] <= B and F[1] < infinity) |
|
F[1] := SRBFS(N1, MIN(B, F[2])) |
|
Insert N1 and F[1] in sorted order |
|
RETURN F[1] |
|
|
|
|
|
RBFS (node : N, value: F(N), bound : B) |
|
IF f(N)>B, RETURN f(N) |
|
IF N is a goal, EXIT algorithm |
|
IF N has no children, RETURN infinity |
|
FOR each child Ni of N |
|
IF f(N)<F(N) THEN F[i] := MAX(F(N),f(Ni)) |
|
ELSE F[i] := f(Ni) |
|
sort Ni
and F[i] in increasing order of F[i] |
|
IF only one child, F[2] := infinity |
|
WHILE (F[1] <= B and F[1] < infinity) |
|
F[1] := RBFS(N1, F[1], MIN(B, F[2])) |
|
Insert N1 and F[1] in sorted order |
|
RETURN F[1] |
|
Notes