Best-first search

related topics
{math, number, function}
{work, book, publish}
{game, team, player}
{rate, high, increase}
{law, state, case}

Best-first search is a search algorithm which explores a graph by expanding the most promising node chosen according to a specified rule.

Judea Pearl described best-first search as estimating the promise of node n by a "heuristic evaluation function f(n) which, in general, may depend on the description of n, the description of the goal, the information gathered by the search up to that point, and most important, on any extra knowledge about the problem domain."[1] [2]

Some authors have used "best-first search" to refer specifically to a search with a heuristic that attempts to predict how close the end of a path is to a solution, so that paths which are judged to be closer to a solution are extended first. This specific type of search is called greedy best-first search.[2]

Efficient selection of the current best candidate for extension is typically implemented using a priority queue.

The A* search algorithm is an example of best-first search. Best-first algorithms are often used for path finding in combinatorial search.

Contents

Algorithm [

OPEN = [initial state]
while OPEN is not empty
do
 1. Remove the best node from OPEN, call it n.
 2. If n is the goal state, backtrace path to n (through recorded parents) and return path.
 3. Create n's successors.
 4. Evaluate each successor, add it to OPEN, and record its parent.
done

Note that this version of the algorithm is not complete, i.e. it does not always find a possible path between two nodes even if there is one. For example, it gets stuck in a loop if it arrives at a dead end, that is a node with the only successor being its parent. It would then go back to its parent, add the dead-end successor to the OPEN list again, and so on.

The following version extends the algorithm to use an additional CLOSED list, containing all nodes that have been evaluated and will not be looked at again. As this will avoid any node being evaluated twice, it is not subject to infinite loops.

OPEN = [initial state]
CLOSED = []
while OPEN is not empty
do
 1. Remove the best node from OPEN, call it n, add it to CLOSED.
 2. If n is the goal state, backtrace path to n (through recorded parents) and return path.
 3. Create n's successors.
 4. For each successor do:
       a. If it is not in CLOSED: evaluate it, add it to OPEN, and record its parent.
       b. Otherwise: change recorded parent if this new path is better than previous one.
done

Also note that the given pseudo code of both versions just terminates when no path is found. An actual implementation would of course require special handling of this case.

[edit] Greedy BFS

Using a greedy algorithm, expand the first successor that has the parent and with a better heuristic. After a successor is made and analyzed, two cases arise [4]:

    Full article ▸

related documents
Lyapunov fractal
LALR parser
Contraction mapping
Nearest neighbour algorithm
Blum Blum Shub
Complete measure
Composite number
Group homomorphism
Zero divisor
Normal morphism
RP (complexity)
Partition of unity
Linear congruence theorem
Axiom of union
Sophie Germain prime
Multiple inheritance
Baire category theorem
Permutation group
Mutual recursion
Characteristic subgroup
Zhu Shijie
Up to
Tree structure
Hamiltonian path problem
Chosen-plaintext attack
Weak entity
Complete category
Data set
Category of sets
Sed