factor. This approach has control over the sub-optimality bound, but wastes a lot of com-
putation since each search iteration duplicates most of the efforts of the previous searches.
One could try to employ incremental heuristic searches (e.g., [4]), but the sub-optimality
bounds for each search iteration would no longer be guaranteed.
To this end we propose the ARA* (Anytime Repairing A*) algorithm, which is an
efficient anytime heuristic search that also runs A* with inflated heuristics in succession
but reuses search efforts from previous executions in such a way that the sub-optimality
bounds are still satisfied. As a result, a substantial speedup is achieved by not re-computing
the state values that have been correctly computed in the previous iterations. We show the
efficiency of ARA* on two different domains. An evaluation of ARA* on a simulated robot
kinematic arm with six degrees of freedom shows up to 6-fold speedup over the succession
of A* searches. We also demonstrate ARA* on the problem of planning a path for a mobile
robot that takes into account the robot’s dynamics.
The only other anytime heuristic search known to us is Anytime A*, described in [8]. It
also first executes an A* with inflated heuristics and then continues to improve a solution.
However, the algorithm does not have control over its sub-optimality bound, except by
selecting the inflation factor of the first search. Our experiments show that ARA* is able
to decrease its bounds much more gradually and, moreover, does so significantly faster.
Another advantage of ARA* is that it guarantees to examine each state at most once during
its first search, unlike the algorithm of [8]. This property is important because it provides
a bound on the amount of time before ARA* produces its first plan. Nevertheless, as
mentioned later, [8] describes a number of very interesting ideas that are also applicable to
ARA*.
2 The ARA* Algorithm
2.1 A* with Weighted Heuristic
Normally, A* takes as input a heuristic h(s) which must be consistent. That is, h(s) ≤
c(s, s
0
) + h(s
0
) for any successor s
0
of s if s 6= s
g oal
and h(s) = 0 if s = s
g oal
. Here
c(s, s
0
) denotes the cost of an edge from s to s
0
and has to be positive. Consistency, in
its turn, guarantees that the heuristic is admissible: h(s) is never larger than the true cost
of reaching the goal from s. Inflating the heuristic (that is, using ∗ h(s) for > 1)
often results in much fewer state expansions and consequently faster searches. However,
inflating the heuristic may also violate the admissibility property, and as a result, a solution
is no longer guaranteed to be optimal. The pseudocode of A* with inflated heuristic is
given in Figure 1 for easy comparison with our algorithm, ARA*, presented later.
A* maintains two functions from states to real numbers: g(s) is the cost of the current
path from the start node to s (it is assumed to be ∞ if no path to s has been found yet), and
f(s) = g(s)+∗h(s) is an estimate of the total distance from start to goal going through s.
A* also maintains a priority queue, OPEN, of states which it plans to expand. The OPEN
queue is sorted by f (s), so that A* always expands next the state which appears to be on
the shortest path from start to goal. A* initializes the OPEN list with the start state, s
start
(line 02). Each time it expands a state s (lines 04-11), it removes s from OPEN. It then
updates the g-values of all of s’s neighbors; if it decreases g(s
0
), it inserts s
0
into OPEN.
A* terminates as soon as the goal state is expanded.
01 g (s
start
) = 0; OPEN = ∅;
02 insert s
start
into OPEN with f(s
start
) = ∗ h(s
start
);
03 while(s
goal
is not expanded)
04 remove s with the smallest f-value from OPEN;
05 for each successor s
0
of s
06 if s
0
was not visited before then
07 f(s
0
) = g(s
0
) = ∞;
08 if g (s
0
) > g(s) + c(s, s
0
)
09 g (s
0
) = g(s) + c(s, s
0
);
10 f(s
0
) = g(s
0
) + ∗ h(s
0
);
11 insert s
0
into OPEN with f(s
0
);
Figure 1: A* with heuristic weighted by ≥ 1