Uniform-cost search

Graph and tree search algorithms
Alpha-beta pruning A* B* Beam Bellman–Ford algorithm Best-first Bidirectional Borůvka's algorithm Breadth-first D* Depth-first Depth-limited Dijkstra's algorithm Floyd–Warshall algorithm Hill climbing Iterative deepening depth-first Kruskal's algorithm Johnson's algorithm Lexicographic breadth-first Uniform-cost more
Related topics
Dynamic programming Search games

In computer science, uniform-cost search (UCS) is a tree search algorithm used for traversing or searching a weighted tree, tree structure, or graph. The search begins at the root node. The search continues by visiting the next node which has the least total cost from the root. Nodes are visited in this manner until a goal state is reached.

Typically, the search algorithm involves expanding nodes by adding all unexpanded neighboring nodes that are connected by directed paths to a priority queue. In the queue, each node is associated with its total path cost from the root, where the least-cost paths are given highest priority. The node at the head of the queue is subsequently expanded, adding the next set of connected nodes with the total path cost from the root to the respective node. The uniform-cost search is complete and optimal if the cost of each step exceeds some positive bound ε. The worst-case time and space complexity is O(b^{1 + C*/ε}), where C* is the cost of the optimal solution. When all step costs are equal, this becomes O(b^{d + 1}).

Pseudocode

procedure UniformCostSearch(Graph, root, goal)

node := root, cost = 0

frontier := priority queue containing node only

explored := empty set

do

if frontier is empty

return failure

node := frontier.pop()

if node is goal

return solution

explored.add(node)

for each of node's neighbors n

if n is not in explored

if n is not in frontier

frontier.add(n)

if n is in frontier with higher cost

replace existing node with n

Example

Expansion showing the explored set and the frontier (priority queue):
Start Node: A
Goal Node: G

Step 1
Frontier:

Node	A
Cost	0

Explored: -

Step 2
Expand A
Frontier:

Node	D	B
Cost	3	5

Explored: A

Step 3
Expand D
Frontier:

Node	B	E	F
Cost	5	5	5

Explored: A D

Step 4
Expand B
Frontier:

Node	E	F	C
Cost	5	5	6

Explored: A D B

Step 5
Expand E
Frontier:

Node	F	C
Cost	5	6

Explored: A D B E

Note: B was not added to the priority queue because it was already explored

Step 6
Expand F
Frontier:

Node	C	G
Cost	6	8

Explored: A D B E F

Step 7
Expand C
Frontier:

Node	G
Cost	8

Explored: A D B E F C

Step 8
Expand G
Found the path: A to D to F to G

Relationship to other algorithms

Dijkstra's algorithm, which is perhaps better-known, can be regarded as a variant of uniform-cost search, where there is no goal state and processing continues until all nodes have been removed from the priority queue, i.e. until shortest paths to all nodes (not just a goal node) have been determined. As in Dijkstra's algorithm, UCS guarantees that (if all edge weights are non-negative) the shortest path to a particular node has been found once the node is extracted from the priority queue.

Uniform-cost search is a special case of the A* search algorithm if its heuristic is a constant function. If A* is used with a monotonic heuristic, then it can be turned into a uniform cost search by subtracting from each edge cost the decrease in heuristic value along that edge. Breadth-first search (BFS) is a special case of uniform-cost search when all edge costs are positive and identical. Where BFS first visits the node with the shortest path length (number of nodes) from the root node, UCS first visits the node with the shortest path costs (sum of edge weights) from the root node.

Uniform-cost search is a variant of best-first search.