Iterative implementation of the forward Anytime Dynamic A* (AD*-f) search algorithm.
\n *\n *AD* is an anytime, dynamic search algorithm. It is able to obtain suboptimal-bounded solutions,\n * tuning the quality of the solution based on the available search time (this is done by adjusting\n * the heuristic inflation parameter, epsilon). This algorithm is executed\n * iteratively improving the quality of the solution and reusing previous search efforts. The algorithm\n * also takes into account the changes produced over the graph arc costs to incrementally repair\n * the previous solution. AD* provides anytime results and an efficient\n * way to solve dynamic search problems.
\n *\n *This is the forward implementation of AD*, the algorithm starts exploring the state space\n * from the beginning state and trying to reach a goal state (or multiple ones).
\n *\n *Reference:\n * Maxim Likhachev, David Ferguson, Geoffrey Gordon, Anthony (Tony) Stentz, and Sebastian Thrun,\n * \n * \"Anytime Dynamic A*: An Anytime, Replanning Algorithm\"\n * Proceedings of the International Conference on Automated Planning and Scheduling (ICAPS), June, 2005.
\n *\n * @param class defining the action\n * @param\n * Implementation of the A* algorithm. The A* algorithm extends the original\n * Dijkstra's algorithm by including heuristics to improve the search. By default,\n * the implementation uses a {@link java.util.PriorityQueue} for the nodes, which requires\n * {@literal O(log n)} time for insertions. The queue can be changed to use another\n * type of queue, for example a fibonacci heap as a queue, which works with constant amortized\n * time for insertions.\n *
\n *\n * Original paper:\n * Hart, Peter E., Nils J. Nilsson, and Bertram Raphael. \"A formal basis for the heuristic determination of minimum cost paths.\". IEEE Transactions on Systems Science and Cybernetics 4.2 (1968): 100-107.\n *\n * @param action type.\n * @param\n * Executes the search algorithm and invokes the method\n * {@link SearchListener#handle(Object)} passing the current\n * explored node to the listener.\n *
\n *\n *\n * {@code Hipster.createDijkstra(problem).search(new Algorithm.SearchListener() {\n * @Override\n * public void handle(Node node) {\n * // Do something with the node.\n * }\n * });\n * }\n * \n *\n * @param listener listener used to receive the explored nodes.\n */\n public void search(SearchListener\n * Optimized implementation of the Bellman-Ford algorithm. The main difference with the standard version\n * of Bellman-Ford is that this implementation does not relax all edges at each iteration. This implies that\n * the first time the goal state is reached, the cost may not be the optimal one. The optimal cost is only guaranteed\n * when the queue is empty (when bellmanFordIt.hasNext() == false).\n *
\n *\n * Original paper:\n * Bellman, R. \"On a routing problem\". Quarterly of Applied Mathematics (1958) 16: 87–90.\n *\n * @param action type.\n * @param\n * Breadth First Search (BFS) implementation. This is an uninformed algorithm that explores\n * first the neighbors at distance 1 (direct neighbors), then the neighbors at distance 2\n * (neighbors of the neighbors), and so on. The algorithm is complete but not optimal\n * (it is only optimal if the cost of the problem is uniform and each transition has a cost of one).\n *
\n *\n * See this Wikipedia article for more information about BFS.\n *\n * @param action type.\n * @param\n * Depth First Search (DFS) is a blind algorithm that performs an exploration\n * of the graph in a way that always reaches the deepest node before backtracking.\n * The Hipster implementation is a graph-based search that can handle cycles.\n * This algorithm is complete (it always finds a solution if it exists) but not\n * optimal.\n *
\n *\n * For more information see this article of the Wikipedia about DFS.\n *\n * @author Pablo Rodríguez Mier <pablo.rodriguez.mier@usc.es>\n */\npublic class DepthFirstSearch\n * In computer science maximumDepth-limited search is an algorithm to explore the vertices of a graph.\n * It is a modification of maximumDepth-first search and is used for example in the iterative deepening\n * maximumDepth-first search algorithm.\n *
\n *\n * For more information see this article of the Wikipedia about DLS.\n *\n * @author Gabriella Zekany\n */\npublic class DepthLimitedSearch\n * Implementation of the IDA* algorithm. Similar to Iterative DFS but using heuristics to limit\n * the space search and keeping a very low memory usage.\n *
\n *\n * Original paper:\n * Richard E. Korf \"Depth-first Iterative-Deepening: An Optimal Admissible Tree Search.\",\n * Artificial Intelligence, vol. 27, pp. 97-109, 1985.\n *\n * @param action type.\n * @param