Iterative deepening A*

Iterative deepening A*

Class	Search algorithm
Data structure	Tree, Graph
Worst-case space complexity	${\displaystyle O(d)}$

Iterative deepening A* (IDA*) is a graph traversal and path search algorithm that can find the shortest path between a designated start node and any member of a set of goal nodes in a weighted graph. It is a variant of iterative deepening depth-first search that borrows the idea to use a heuristic function to conservatively estimate the remaining cost to get to the goal from the A* search algorithm. Since it is a depth-first search algorithm, its memory usage is lower than in A*, but unlike ordinary iterative deepening search, it concentrates on exploring the most promising nodes and thus does not go to the same depth everywhere in the search tree. Unlike A*, IDA* does not utilize dynamic programming and therefore often ends up exploring the same nodes many times.

While the standard iterative deepening depth-first search uses search depth as the cutoff for each iteration, the IDA* uses the more informative ${\displaystyle f(n)=g(n)+h(n)}$, where ${\displaystyle g(n)}$ is the cost to travel from the root to node ${\displaystyle n}$ and ${\displaystyle h(n)}$ is a problem-specific heuristic estimate of the cost to travel from ${\displaystyle n}$ to the goal.

The algorithm was first described by Richard Korf in 1985. ^[1]

Description

Iterative-deepening-A* works as follows: at each iteration, perform a depth-first search, cutting off a branch when its total cost ${\displaystyle f(n)=g(n)+h(n)}$ exceeds a given threshold. This threshold starts at the estimate of the cost at the initial state, and increases for each iteration of the algorithm. At each iteration, the threshold used for the next iteration is the minimum cost of all values that exceeded the current threshold. ^[1]

As in A*, the heuristic has to have particular properties to guarantee optimality (shortest paths). See Properties below.

Pseudocode

pathcurrent search path (acts like a stack)nodecurrent node(last node in current path)gthe cost to reach current nodefestimated cost of the cheapest path (root..node..goal)h(node)           estimated cost of the cheapest path (node..goal)cost(node, succ)  step cost functionis_goal(node)     goal testsuccessors(node)  node expanding function, expand nodes ordered by g + h(node)ida_star(root)    return either NOT_FOUND or a pair with the best path and its costprocedureida_star(root)     bound := h(root)     path := [root]     loopt := search(path, 0, bound)         ift = FOUND then return(path, bound)ift = ∞ then return NOT_FOUND         bound := tend loopend procedurefunctionsearch(path, g, bound)     node := path.last     f := g + h(node)     iff > boundthen returnfifis_goal(node) then return FOUND     min := ∞     forsuccinsuccessors(node) doifsuccnotinpaththenpath.push(succ)             t := search(path, g + cost(node, succ), bound)             ift = FOUND then return FOUND             ift < minthenmin := tpath.pop()         endifend forreturnminend function

Properties

Like A*, IDA* is guaranteed to find the shortest path leading from the given start node to any goal node in the problem graph, if the heuristic function h is admissible, ^[1] that is

${\displaystyle h(n)\leq h^{*}(n)}$

for all nodes n, where h* is the true cost of the shortest path from n to the nearest goal (the "perfect heuristic"). ^[2]

IDA* is beneficial when the problem is memory constrained. A* search keeps a large queue of unexplored nodes that can quickly fill up memory. By contrast, because IDA* does not remember any node except the ones on the current path, it requires an amount of memory that is only linear in the length of the solution that it constructs. Its time complexity is analyzed by Korf et al. under the assumption that the heuristic cost estimate h is consistent, meaning that

${\displaystyle h(n)\leq \mathrm {cost} (n,n')+h(n')}$

for all nodes n and all neighbors n' of n; they conclude that compared to a brute-force tree search over an exponential-sized problem, IDA* achieves a smaller search depth (by a constant factor), but not a smaller branching factor. ^[3]

Recursive best-first search is another memory-constrained version of A* search that can be faster in practice than IDA*, since it requires less regenerating of nodes. ^{[2] : 282–289}

Applications

Applications of IDA* are found in such problems as planning. ^[4] Solving the Rubik's Cube is an example of a planning problem that is amenable to solving with IDA*. ^[5]

References

1. Korf, Richard E. (1985). "Depth-first Iterative-Deepening: An Optimal Admissible Tree Search" (PDF). Artificial Intelligence . 27: 97–109. doi:10.1016/0004-3702(85)90084-0. S2CID   10956233.
2. Bratko, Ivan (2001). Prolog Programming for Artificial Intelligence. Pearson Education.
3. Korf, Richard E.; Reid, Michael; Edelkamp, Stefan (2001). "Time complexity of iterative-deepening-A∗". Artificial Intelligence. 129 (1–2): 199–218. doi: 10.1016/S0004-3702(01)00094-7 .
4. Bonet, Blai; Geffner, Héctor C. (2001). "Planning as heuristic search". Artificial Intelligence. 129 (1–2): 5–33. doi:10.1016/S0004-3702(01)00108-4. hdl: 10230/36325 .
5. Richard Korf (1997). "Finding Optimal Solutions to Rubik's Cube Using Pattern Databases" (PDF). Archived from the original (PDF) on 2019-08-19. Retrieved 2023-09-11.