# 2 Full Recursive Best ```Recursive Best-First Search
• RBFS is a linear-space algorithm
that expands nodes in best-first
order even with a non-monotonic
cost function and generates fewer
nodes than iterative deepening with
a monotonic cost function.
Simple Recursive Best-First Search
• SRBFS uses a local cost threshold for each
recursive call.
• It takes 2 arguments:
– a node
– an upper bound
• It explores the subtree below the node as long
as it contains frontier nodes whose costs do not
exceed the upped bound.
• Every node has an upper bound on cost.
• Upper bound=min(upper bound on it’s
parent,current value of it’s lowest cost brother)
SRBFS example with nonmonotonic cost function
5
2
1
Expand the
root and
compute the
costs of the
children
2
SRBFS example with nonmonotonic cost function
5
5
2
2
1
1
2
4
Expand the
root and
compute the
costs of the
children
2
3
Expand the right child ,
evaluate grandchildren.
The recursive call
terminates and return
the minimum value of
children
SRBFS example with nonmonotonic cost function
5
5
5
2
2
1
1
2
2
4
Expand the
root and
compute the
costs of the
children
2
3
3
Expand the right child ,
evaluate grandchildren.
The recursive call
terminates and return
the minimum value of
children
The backedup value of 3
is stored as
the new
value of the
right child
3
SRBFS example with cost
equal to depth
1
1
1
SRBFS example with cost
equal to depth
1
1
1
2
2
SRBFS example with cost
equal to depth
1
2
2
SRBFS example with cost
equal to depth
1
2
2
2
2
2
SRBFS example with cost
equal to depth
1
2
2
2
3
2
2
3
SRBFS example with cost
equal to depth
1
2
2
2
3
2
SRBFS example with cost
equal to depth
1
2
3
2
2
3
3
2
SRBFS example with cost
equal to depth
1
3
2
3
2
SRBFS example with cost
equal to depth
3
2
SRBFS -The Algorithm
SRBFS ( node: N ,bound B)
IF f( N) &gt; 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 = infinity
WHILE (F  B and f &lt; infinity)
F := SRBFS (N1, MIN(B, F))
insert N1 and F in sorted order
RETURN F
SRBFS -Unefficiency

SRBFS expands nodes in best-first order, even if the
cost function is non-monotonic.Unfortunately, however,
SRBFS is inefficient - much of the work done is
redundant.
7
8
8
7
2
8
2
8
2
Continuing the previous example will reach this state
Full Recursive Best-First Search

The way to avoid this inefficiency is for children to
inherit their parent’s values as their own, if the parent’s
values are greater than the children’s values.
7
2
8
2
8
2
7
7
8
7
8
7
Inefficiency of SRBFS and its solution.
Full Recursive Best-First Search
• In order to be expanded, the upper bound on a
node must be at least as large as its stored value.
• If a node has been previously expanded, its stored
value will be greater than its static value.
• If the stored value of a node is greater than its static
value, its stored value is the minimum of the last
stored values of its children.
In general, a parent’s stored value is passed
down to its children, which inherit the value only
if it exceeds both the parent’s static value and
the child’s static value.
Full RBFS -The Algorithm
RBFS ( node: N ,value: F(N), bound B)
IF f( N) &gt; 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)
IF f(N) &lt; 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 = infinity
WHILE (F  B and f &lt; infinity)
F := SRBFS (N1, MIN(B, F))
insert N1 and F in sorted order
RETURN F
Full Recursive Best-First Search
Example
3
4
4
Full Recursive Best-First Search
Example
3
3
4
4
3
3
Full Recursive Best-First Search
Example
3
3
4
4
3
3
3
3
3
Full Recursive Best-First Search
Example
3
3
4
4
3
3
3
3
4
3
4
RBFS vs SRBFS
• RBFS behaves differently depending on
whether it is expanding new nodes, or
previously expanded nodes:
– New nodes - proceeds like Best-First.
– Previously expanded nodes - behaves like BFS
until it reaches a lowest - cost node.Then it
reverts back to Best-First.
Space Complexity of SRBFS
and RBFS
The space complexity of SRBFS and RBFS is O(bd)
where b is the branching factor and d is the maximum
search depth.
Time Complexity of SRBFS and
RBFS
• The asymptotic time complexity of SRBFS
and RBFS is the number of node
generations.
• The actual number of nodes generated
depends on the particular cost function.
Worst case Time Complexity
• As with ID, the worst-case time complexity
occurs when
– all nodes have unique cost values.
– they must be arranged so that successive
nodes in an ordered sequence of cost values
are in different subtrees of the root node.
Worst case Time Complexity
• In order to expand each new node to depth
d, both SRBFS and RBFS must abandon
their current path all the way back to the
root.
0
2
1
3
7
9
11
6c
4c
5c
1
c
3
8
1
0
1
2
1
4
Worst case Time Complexity
The worst case time complexity of SRBFS and
RBFS is O(b2d-1)
RBFS vs. ID
• If the cost function is non-monotonic, the two
algorithms are not directly comparable.
• RBFS generate fewer nodes than ID on average.
• If the expected number of zero-cost children of a
node is less then 1, then DFBnB will run in
exponential time in the search depth but the space
complexity is linear.
```