### 3.7.2 Multiple-Path Pruning

There is often more than one path to a node. If only one path is required, a search algorithm can prune from the frontier any path that leads to a node to which it has already found a path.

**Multiple-path pruning** can be
implemented by keeping a **closed list** of nodes that have been
expanded. When a path is selected at
line 13
of Figure 3.4, if its last
node is in the closed list, the path can be discarded. Otherwise, its
last node is added to the closed list, and the algorithm proceeds as
before.

This approach does not necessarily guarantee that the shortest path is not discarded. Something more sophisticated may have to be done to guarantee that an optimal solution is found. To ensure that the search algorithm can still find a lowest-cost path to a goal, one of the following can be done:

- Make sure that the first path found to any node is a lowest-cost path to that node, then prune all subsequent paths found to that node, as discussed earlier.
- If the search algorithm finds a lower-cost path to a node than one already found,
it can remove all paths that used the higher-cost path to the
node (because these cannot be on an optimal solution). That is, if there is
a path
*p*on the frontier*⟨s,...,n,...,m⟩*, and a path*p'*to*n*is found that is shorter than the portion of the path from*s*to*n*in*p*, then*p*can be removed from the frontier. - Whenever the search finds a lower-cost path to a node than a path to
that already found, it can incorporate a new initial section
on the paths that have extended the initial path. Thus, if there is
a path
*p=⟨s,...,n,...,m⟩*on the frontier, and a path*p'*to*n*is found that is shorter than the portion of*p*from*s*to*n*, then*p'*can replace the initial part of*p*to*n*.

The first of these alternatives allows the use of the closed list without losing the ability to find an optimal path. The others require more sophisticated algorithms.

In lowest-cost-first search, the first path found to a node (i.e., when the node is selected from the frontier) is the least-cost path to the node. Pruning subsequent paths to that node cannot remove a lower-cost path to that node, and thus pruning subsequent paths to each node still enables an optimal solution to be found.

As described earlier, *A ^{*}* does not guarantee
that when a path to a node is selected for the first time it is the
lowest cost path to that node. Note that the
admissibility theorem guarantees this for
every path to a

*goal*node but not for every path. To see when pruning subsequent paths to a node can remove the optimal solution, suppose the algorithm has selected a path

*p*to node

*n*for expansion, but there exists a lower-cost path to node

*n*, which it has not found yet. Then there must be a path

*p'*on the frontier that is the initial part of the lower-cost path. Suppose path

*p'*ends at node

*n'*. It must be that

*f(p) ≤ f(p')*, because

*p*was selected before

*p'*. This means that

cost(p) + h(n) ≤ cost(p')+h(n').

If the path to
*n* via *p'* has a lower cost than the path *p*,

cost(p') + d(n', n)<cost(p),

where *d(n' , n)* is the actual cost of the shortest path
from node *n'* to *n*. From these two equations, we can derive

d(n', n)<cost(p)-cost(p') ≤ h(p') - h(p)= h(n') - h(n).

Thus, we can ensure that the first path found to any node is the
lowest-cost path if
*|h(n')-h(n)| ≤ d(n',n)* for any two nodes *n* and *n'*. The
**monotone restriction** on *h* is that *|h(n')-h(n)| ≤ d(n',n)* for any two nodes *n* and *n'*. That is, the difference in
the heuristic values for two nodes must be less than or equal to the actual cost
of the lowest-cost path
between the nodes. It
is applicable to, for example, the heuristic function of Euclidean
distance (the
straight-line distance in an *n*-dimensional Euclidean space) between
two points when the cost function is distance. It is also typically
applicable when the heuristic function is a solution to a simplified problem that has shorter solutions.

With the monotone restriction,
the *f*-values on the frontier are monotonically non-decreasing. That
is, when
the frontier is expanded, the *f*-values do not get smaller. Thus, with
the monotone restriction, subsequent paths to any node can be pruned in
*A ^{*}* search.

Multiple-path pruning subsumes a cycle check, because a cycle is another path to a node and is therefore pruned. Multiple-path pruning can be done in constant time, if the graph is explicitly stored, by setting a bit on each node to which a path has been found. It can be done in logarithmic time (in the number of nodes expanded, as long as it is indexed appropriately), if the graph is dynamically generated, by storing the closed list of all of the nodes that have been expanded. Multiple-path pruning is preferred over cycle checking for breadth-first methods where virtually all of the nodes considered have to be stored anyway. For depth-first search strategies, however, the algorithm does not otherwise have to store all of the nodes already considered. Storing them makes the method exponential in space. Therefore, cycle checking is preferred over multiple-path checking for depth-first methods.