Given the importance in the solution of many AI problems of search it is important to have available search methods that require a minimum of resources, particularly in light of the fact that many AI problems have extremely large search spaces. Richard Korf presents an significant innovation to search with an algorithm that requires only linear-space yet maintains a best-first order of expansion of the nodes in the search space. More importantly the Korf's technique is robust enough to handle non-monotonic cost evaluation functions.

This RBFS (Recursive Best-First Search) algorithm expands nodes in a best-first order by exploring the children of a node recursively until all children found cost function exceeds a specified cost. A fringe (unexpanded) nodes' costs are augmented to reflect the best cost of all of the fringe node's children that have been previously explored (upon return from a recursive exploration of a node's children, all child nodes are discarded). This allows the RBFS to maintain a linear-space record of a solution path (which is O(branch*depth)) (the time complexity is only slightly better than iterative deepening).

I think the most significant advantage of RBFS is that it handles non-monotonic cost functions without loosing its best-first characteristic. This feature, as is empirically demonstrated in random N x N puzzles (i.e. Eight, Fifteen, and Twenty-four Puzzles), gives faster solutions using a weighted A* cost function (over several other search methods) at the expense of longer (i.e. non-optimal) solution paths. It is interesting to note that the actual weighting of the heuristic function (i.e. the W in f(n) = g(n) + W*h(n)) has U-shaped characteristic when plotting the number of nodes versus the relative weighting factor W. The differences in nodes generated is as high as six orders of magnitude!)

As one might expect there are a number of problems with RBFS. One of the more subtle ones is that it is possible for it to get stuck in a (semi-) infinite loop if the costs of a set of children are an infinitely increasing sequence with a finite upper bound (such as 1/2, 3/4, 7/8, etc.). I call it a (semi-) infinite loop as this loop should terminate eventually as the decimal or floating point precision runs out (but this would not be the case in a language that supports fractional integers, such as Lisp). Another more obvious problem is that RBFS treats redundant nodes (i.e. in a loop) as unique because the route to the node is significant. This problem can be partly overcome by applying techniques used in other algorithms to check for revisiting nodes (Korf suggests several, including MA* and MIDA*).

An important consideration of the efficiency of the RBFS is cost of node generation and regeneration. As this is a constant increase in the overhead of RBFS, it should be considered when applying this algorithm to searches that have a large node generation cost relative to other aspects of the search cost.

As a final note I would like to say that I am intrigued by irregularity of the nodes generated versus relative weighting of the h(n) term and the fact that the node regeneration overhead is seemingly constant independent of the problem size. It seems that there is something significant going on here, but I can't quite see what it is.