CS 371: Introduction to Artificial Intelligence
| 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] | ||