Lecture 3: Uniform
Cost Search and A*
Mark Hasegawa-Johnson, January 2021
With some slides by Svetlana Lazebnik, 9/2016
Distributed under CC-BY 3.0
Title image: By Harrison Weir - From reuseableart.com,
Public Domain,
https://commons.wikimedia.org/w/index.php?curid=47
879234
Review: DFS and BFS
• Breadth-first search
• Frontier is a queue: expand the shallowest node
• Complete: always finds a solution, if one exists
• Optimal (finds the best solution) if all actions have the same cost.
• Time complexity: 𝑂{𝑏 ! }
• Space complexity: 𝑂{𝑏 ! }.
• Depth-first search – utility depends on relationship between m and d
• Frontier is a stack: expand the deepest node
• Not complete (might never find a solution, if m is infinite)
• Not optimal (returned solution is rarely the best one)
• Time complexity: 𝑂{𝑏 " }
• Space complexity: 𝑂{𝑏𝑚}.
Outline of today’s lecture
1. Uniform Cost Search (UCS): like BFS, but for actions that have different
costs
• Complete: always finds a solution, if one exists
• Optimal: finds the best solution
• Time complexity = # nodes that have cost < goal
• Space complexity = # nodes that have cost < goal
2. Heuristics, e.g., Manhattan distance
3. Greedy Best-first search
4. A*: Like UCS but adds an estimate of the remaining path length
• Complete: always finds a solution, if one exists
• Optimal: finds the best solution
• Time complexity = # nodes that have cost+heuristic < goal
• Space complexity = # nodes that have cost+heuristic < goal
An example for which BFS is not optimal: Romania
Arad
Timisoara Sibiu Zerind
Lugoj RV Fagaras Oradea
Mehadia C P Bucharest
BFS returns this path,
because it requires
only 3 actions.
Cost = 450 km
An example for which BFS is not optimal: Romania
Arad
Timisoara Sibiu Zerind
Lugoj RV Fagaras Oradea
Mehadia C P Bucharest
Bucharest
It would have been
better to find this
path!
Cost = 418 km
The solution: Uniform Cost Search
• Breadth-first search (BFS): Next node expanded is the one with the
fewest required actions
• Frontier is a queue
• First node into the queue is the first one expanded (FIFO)
• Uniform cost search (UCS): Next node expanded is the one with the
lowest accumulated path cost
• Frontier is a priority queue
• Lowest-cost node is the first one expanded
Example of UCS: Romania
Arad
Arad:0
Example of UCS: Romania
Arad
Timisoara Sibiu Zerind
Zerind:75, Timisoara:118, Sibiu:140
Example of UCS: Romania
Arad
Timisoara Sibiu Zerind
Oradea
Timisoara:118, Sibiu:140, Oradea:146
Example of UCS: Romania
Arad
Timisoara Sibiu Zerind
Lugoj Oradea
Sibiu:140, Oradea:146, Lugoj:239
Example of UCS: Romania
Arad
Timisoara Sibiu Zerind
Lugoj RV Fagaras Oradea
Oradea:146, Rimnicu Vilcea:220, Lugoj:239, Fagaras:239
Example of UCS: Romania
Arad
Timisoara Sibiu Zerind
Lugoj RV Fagaras Oradea
Rimnicu Vilcea:220, Lugoj:239, Fagaras:239
Example of UCS: Romania
Arad
Timisoara Sibiu Zerind
Lugoj RV Fagaras Oradea
C P
Lugoj:239, Fagaras:239, Pitesti:317, Craiova:366
Example of UCS: Romania
Arad
Timisoara Sibiu Zerind
Lugoj RV Fagaras Oradea
Mehadia C P
Fagaras:239, Mehadia:309, Pitesti:317, Craiova:366
Example of UCS: Romania
Arad
Timisoara Sibiu Zerind
Lugoj RV Fagaras Oradea
Mehadia C P Bucharest
Mehadia:309, Pitesti:317, Craiova:366, Bucharest:450
Example of UCS: Romania
Arad
Timisoara Sibiu Zerind
Lugoj RV Fagaras Oradea
Mehadia C P Bucharest
Dobreta
Pitesti:317, Craiova:366, Dobreta:384, Bucharest:450
Example of UCS: Romania
Arad
Timisoara Sibiu Zerind
Lugoj RV Fagaras Oradea
Mehadia C P
Dobreta Bucharest
Craiova:366, Dobreta:384, Bucharest:418
Example of UCS: Romania
Arad
Timisoara Sibiu Zerind
Lugoj RV Fagaras Oradea
Mehadia C P
Dobreta Bucharest
Dobreta:384, Bucharest:418
Example of UCS: Romania
Arad
Timisoara Sibiu Zerind
Lugoj RV Fagaras Oradea
Mehadia C P
Dobreta Bucharest
Bucharest:418
GOAL!!!! GOL!!!!!
Image by Rick Dikeman, GFDL 1996, https://commons.wikimedia.org/wiki/File:Football_iu_1996.jpg
Outline of today’s lecture
1. Uniform Cost Search (UCS): like BFS, but for actions that have different
costs
• Complete: always finds a solution, if one exists
• Optimal: finds the best solution
• Time complexity = # nodes that have cost < goal
• Space complexity = # nodes that have cost < goal
2. Heuristics, e.g., Manhattan distance
3. Greedy Best-first search
4. A*: Like UCS but adds an estimate of the remaining path length
• Complete: always finds a solution, if one exists
• Optimal: finds the best solution
• Time complexity = # nodes that have cost+heuristic < goal
• Space complexity = # nodes that have cost+heuristic < goal
Heuristics main idea
Instead of choosing the node with the smallest total cost so far (UCS),
why not choose the node that’s CLOSEST TO GOAL,
and expand that one first?
Why not choose the node CLOSEST TO GOAL?
• Answer: because we don’t know Start state
which node that is!!
• Example: which of these two is
closest to goal?
Goal state
We don’t know which state is closest to goal
• Finding the shortest path is the Start state
whole point of the search
• If we already knew which state
was closest to goal, there would
be no reason to do the search
• Figuring out which one is closest,
in general, is a complexity 𝑂 𝑏!
problem.
Goal state
Search heuristics: estimates of distance-to-goal
• Often, even if we don’t know the
distance to the goal, we can Start state
estimate it.
• This estimate is called a
heuristic.
• A heuristic is useful if:
1. Accurate: ℎ(𝑛) ≈ 𝑑(𝑛), where
ℎ(𝑛) is the heuristic estimate,
and 𝑑(𝑛) is the true distance to
the goal
2. Cheap: It can be computed in Goal state
complexity less than 𝑂 𝑏 !
Example heuristic: Manhattan distance
If there were no walls, this would
If there were no walls in the maze, be the path to goal: straight down,
Start state then straight right.
then the number of steps from
position (𝑥" , 𝑦" ) to the goal
position (𝑥# , 𝑦# ) would be 𝑦#
ℎ(𝑛) = |𝑥" − 𝑥# | + |𝑦" − 𝑦# |
𝑦$ Goal state
𝑥
𝑥# 𝑥$
Outline of today’s lecture
1. Uniform Cost Search (UCS): like BFS, but for actions that have different
costs
• Complete: always finds a solution, if one exists
• Optimal: finds the best solution
• Time complexity = # nodes that have cost < goal
• Space complexity = # nodes that have cost < goal
2. Heuristics, e.g., Manhattan distance
3. Greedy Best-first search
4. A*: Like UCS but adds an estimate of the remaining path length
• Complete: always finds a solution, if one exists
• Optimal: finds the best solution
• Time complexity = # nodes that have cost+heuristic < goal
• Space complexity = # nodes that have cost+heuristic < goal
Greedy Best-First Search
Instead of choosing the node with the smallest total cost so far (UCS),
why not choose the node whose
HEURISTIC ESTIMATE
indicates that it might be
CLOSEST TO GOAL?
Greedy Search Example
According to the Manhattan Start state
distance heuristic, these two
nodes are equally far from the
goal, so we have to choose one at
random.
Goal state
Greedy Search Example
Start state
If our random choice goes badly,
we might end up very far from the
goal.
= states in the explored set
= states on the frontier
Goal state
The problem with Greedy Search
Start state
Having gone down a bad path, it’s
very hard to recover, because
now, the frontier node closest to
goal (according to the Manhattan
distance heuristic) is this one:
Goal state
The problem with Greedy Search
Start state
That’s not a useful path…
Goal state
The problem with Greedy Search
Start state
Neither is that one…
Goal state
What went wrong?
Outline of today’s lecture
1. Uniform Cost Search (UCS): like BFS, but for actions that have different
costs
• Complete: always finds a solution, if one exists
• Optimal: finds the best solution
• Time complexity = # nodes that have cost < goal
• Space complexity = # nodes that have cost < goal
2. Heuristics, e.g., Manhattan distance
3. Greedy Best-first search
4. A*: Like UCS but adds an estimate of the remaining path length
• Complete: always finds a solution, if one exists
• Optimal: finds the best solution
• Time complexity = # nodes that have cost+heuristic < goal
• Space complexity = # nodes that have cost+heuristic < goal
The problem with Greedy Search
Among nodes on the frontier, this Start state
one seems closest to goal (smallest
ℎ(𝑛), where ℎ(𝑛) ≤ 𝑑(𝑛)).
But it’s also farthest from the start.
Let’s say 𝑔(𝑛) = total path cost so far.
So the total distance from start to
goal, going through node 𝑛, is
Goal state
𝑐(𝑛) = 𝑔 𝑛 + 𝑑 𝑛 ≥ 𝑔 𝑛 + ℎ(𝑛)
The problem with Greedy Search
Of these three nodes, this one has 15
the smallest 𝑔 𝑛 + ℎ 𝑛
(𝑔(𝑛) + ℎ(𝑛) = 4 + 28 = 32)
So if we want to find the lowest- 13
cost path, then it would be better
to try that node, instead of this
one, which has 2
𝑔 𝑛 + ℎ 𝑛 = 21 + 14 = 35 12
A* notation
• 𝑐(𝑛) = cost of the total path Start state
(START,…,n,…,GOAL).
• 𝑑(𝑛) = distance of the remaining
partial path (n,…,GOAL).
• 𝑔(𝑛) = gone-already on the path
so far, (START,…,n).
• ℎ(𝑛) = heuristic, ℎ(𝑛) ≤ 𝑑(𝑛).
Goal state
𝑐(𝑛) = 𝑔 𝑛 + 𝑑 𝑛 ≥ 𝑔 𝑛 + ℎ(𝑛)
A* Search
• Idea: avoid expanding paths that are already expensive
• The evaluation function f(n) is the estimated total cost of the
path through node n to the goal:
f(n) = g(n) + h(n)
g(n): cost so far to reach n (path cost)
h(n): estimated cost from n to goal (heuristic)
• This is called A* search if and only if the heuristic, h(n), is
admissible. The word “admissible” just means that ℎ(𝑛) ≤
𝑑(𝑛), and therefore, 𝑓(𝑛) ≤ 𝑐(𝑛).
𝑐 𝑚
m
Admissible heuristic S G
n
𝑔 𝑛 ≥ℎ 𝑛
• Suppose we’ve found one path to 𝐺; the path goes through node 𝑚. Since
we’ve calculated the whole path, we know its total path cost to be 𝑐 𝑚 .
• For every other node, 𝑛, we don’t know 𝑐(𝑛), but we know 𝑓(𝑛) = 𝑔(𝑛) +
ℎ(𝑛), and we know that
𝑐 𝑛 ≥𝑓 𝑛
• Therefore we know that
𝐼𝐹 𝑓 𝑛 ≥ 𝑐 𝑚
𝑇𝐻𝐸𝑁 𝑐(𝑛) ≥ 𝑐(𝑚)
• So if 𝑓 𝑛 ≥ 𝑐 𝑚 for every node n that’s still in the frontier, then we know
that m is the best path.
𝑐 𝑚
m
A* Search S G
n
𝑔 𝑛 ≥ℎ 𝑛
Definition: A* SEARCH
• If ℎ 𝑛 is admissible (𝑑(𝑛) ≥ ℎ 𝑛 ), and
• if the frontier is a priority queue sorted according to 𝑔 𝑛 + ℎ(𝑛),
then
• the FIRST path to goal uncovered by the tree search, path 𝑚, is
guaranteed to be the SHORTEST path to goal
(ℎ 𝑛 + 𝑔 𝑛 ≥ 𝑐(𝑚) for every node 𝑛 that is not on path 𝑚)
Example of A*: Romania Suppose we don’t know the distance
from Sibiu to Bucharest on highways,
but we DO know the distance “as the
crow flies.”
ℎ(𝑛) = Euclidean distance (as the
crow flies)
• Sibiu: h(n) = 260km
• Timisoara: h(n) = 410km
• Zerind: h(n) = 422km
Romania using UCS
Arad
Timisoara Sibiu Zerind
Pick this one first?
Zerind:75, Timisoara:118, Sibiu:140
Romania using A*
Arad
Timisoara Sibiu Zerind
No, pick this one first!!!
Sibiu:140+260=400, Zerind:75+422=495, Timisoara:118+410=528
BFS vs. A* Search Example
The heuristic h(n)=Euclidean distance favors nodes on the main diagonal.
Those nodes all have the same g(n)+h(n), so A* evaluates them first.
CC-BY 3.0 by Subh83, 2011, https://en.wikipedia.org/wiki/File:Astar_progress_animation.gif
Outline of today’s lecture
1. Uniform Cost Search (UCS): like BFS, but for actions that have different
costs
• Complete: always finds a solution, if one exists
• Optimal: finds the best solution
• Time complexity = # nodes that have cost < goal
• Space complexity = # nodes that have cost < goal
2. Heuristics, e.g., Manhattan distance
3. Greedy Best-first search
4. A*: Like UCS but adds a lower bound of the remaining path length
• Complete: always finds a solution, if one exists
• Optimal: finds the best solution
• Time complexity = # nodes that have cost+heuristic < goal
• Space complexity = # nodes that have cost+heuristic < goal
