Neha Patil (Editor)

SMA*

Updated on
Edit
Like
Comment
Share on FacebookTweet on TwitterShare on LinkedInShare on Reddit

SMA* or Simplified Memory Bounded A* is a shortest path algorithm based on the A* algorithm. The main advantage of SMA* is that it uses a bounded memory, while the A* algorithm might need exponential memory. All other characteristics of SMA* are inherited from A*.

Contents

Process

Like A*, it expands the most promising branches according to the heuristic. What sets SMA* apart is that it prunes nodes whose expansion has revealed less promising than expected. The approach allows the algorithm to explore branches and backtrack to explore other branches.

Expansion and pruning of nodes is driven by keeping two values of f for every node. Node x stores a value f ( x ) which estimates the cost of reaching the goal by taking a path through that node. The lower the value, the higher the priority. As in A* this value is initialized to h ( x ) + g ( x ) , but will then be updated to reflect changes to this estimate when its children are expanded. A fully expanded node will have an f value at least as high as that of its successors. In addition, the node stores the f value of the best forgotten successor. This value is restored if the forgotten successor is revealed to be the most promising successor.

Starting with the first node, it maintains OPEN, ordered lexicographically by f and depth. When choosing a node to expand, it chooses the best according to that order. When selecting a node to prune, it chooses the worst.

Properties

SMA* has the following properties

  • It works with a heuristic, just as A*
  • It is complete if the allowed memory is high enough to store the shallowest solution
  • It is optimal if the allowed memory is high enough to store the shallowest optimal solution, otherwise it will return the best solution that fits in the allowed memory
  • It avoids repeated states as long as the memory bound allows it
  • It will use all memory available
  • Enlarging the memory bound of the algorithm will only speed up the calculation
  • When enough memory is available to contain the entire search tree, then calculation has an optimal speed

    • Implementation

    The implementation of SMA* is very similar to the one of A*, the only difference is that when there isn't any space left, nodes with the highest f-cost are pruned from the queue. Because those nodes are deleted, the SMA* also has to remember the f-cost of the best forgotten child with the parent node. When it seems that all explored paths are worse than such a forgotten path, the path is re-generated.

    Pseudo code:

    References

    SMA* Wikipedia
    (Text) CC BY-SA