1. CSE 373: Data Structures and Algorithms
Lecture 21: Graphs III

2. Depth-first search
depth-first search (DFS): finds a path between two vertices by exploring each possible path as many steps as possible before backtracking
often implemented recursively

3. DFS example All DFS paths from A to others (assumes ABC edge order)
A -> B -> D
A -> B -> F
A -> B -> F -> E
A -> C
A -> C -> G
What are the paths that DFS did not find?

4. DFS pseudocode Pseudo-code for depth-first search: dfs(v1, v2):
dfs(v1, v2, path):
path += v1.
mark v1 as visited.
if v1 is v2:
path is found.
for each unvisited neighbor vi of v1 where there is an edge from v1 to vi:
if dfs(vi, v2, path) finds a path, path is found.
path -= v1. path is not found.

5. DFS observations guaranteed to find a path if one exists
easy to retrieve exactly what the path is (to remember the sequence of edges taken) if we find it
optimality: not optimal. DFS is guaranteed to find a path, not necessarily the best/shortest path
Example: DFS(A, E) may return A -> B -> F -> E

6. Another DFS example Using DFS, find a path from BOS to LAX. v BOS ORD
JFK
BOS
MIA
ORD
LAX
DFW
SFO v 2 1 3 4 5 6

7. Breadth-first search
breadth-first search (BFS): finds a path between two nodes by taking one step down all paths and then immediately backtracking
often implemented by maintaining a list or queue of vertices to visit
BFS always returns the path with the fewest edges between the start and the goal vertices

8. BFS example All BFS paths from A to others (assumes ABC edge order)
A -> C
A -> E
A -> B -> D
A -> B -> F
A -> C -> G
What are the paths that BFS did not find?

9. BFS pseudocode Pseudo-code for breadth-first search: bfs(v1, v2):
List := {v1}.
mark v1 as visited.
while List not empty:
v := List.removeFirst().
if v is v2:
path is found.
for each unvisited neighbor vi of v where there is an edge from v to vi:
mark vi as visited
List.addLast(vi).
path is not found.

10. BFS observations optimality:
in unweighted graphs, optimal. (fewest edges = best)
In weighted graphs, not optimal. (path with fewest edges might not have the lowest weight)
disadvantage: harder to reconstruct what the actual path is once you find it
conceptually, BFS is exploring many possible paths in parallel, so it's not easy to store a Path array/list in progress
observation: any particular vertex is only part of one partial path at a time
We can keep track of the path by storing predecessors for each vertex (references to the previous vertex in that path)

11. Another BFS example Using BFS, find a path from BOS to LAX. v BOS ORD
JFK
BOS
MIA
ORD
LAX
DFW
SFO v 2 1 3 4 5 6

12. DFS, BFS runtime
What is the expected runtime of DFS, in terms of the number of vertices V and the number of edges E ?
What is the expected runtime of BFS, in terms of the number of vertices V and the number of edges E ?
Answer: O(|V| + |E|)
each algorithm must potentially visit every node and/or examine every edge once.
why not O(|V| * |E|) ?
What is the space complexity of each algorithm?
O(|V| + |E|)
Space: DFS O(1), BFS O(|V| + |E|)

13. VertexInfo class
public class VertexInfo<V> { public V v; public boolean visited; public VertexInfo(V v) { this.v = v; this.clear(); } public void clear() { this.visited = false;

14. Dijkstra's algorithm
Dijkstra's algorithm: finds shortest (minimum weight) path between a particular pair of vertices in a weighted directed graph with nonnegative edge weights
solves the "one vertex, shortest path" problem
basic algorithm concept: create a table of information about the currently known best way to reach each vertex (distance, previous vertex) and improve it until it reaches the best solution
in a graph where:
vertices represent cities,
edge weights represent driving distances between pairs of cities connected by a direct road, Dijkstra's algorithm can be used to find the shortest route between one city and any other

15. Dijkstra pseudocode Dijkstra(v1, v2):
for each vertex v: // Initialization
v's distance := infinity.
v's previous := none.
v1's distance := 0.
List := {all vertices}.
while List is not empty:
v := remove List vertex with minimum distance.
mark v as known.
for each unknown neighbor n of v:
dist := v's distance + edge (v, n)'s weight.
if dist is smaller than n's distance:
n's distance := dist.
n's previous := v.
reconstruct path from v2 back to v1,
following previous pointers.

16. Example: Initialization
Distance(source) = 0
Distance (all vertices but source) = A 2 B  4 1 3 10 C 2 D 2 E    5 8 4 6 F 1 G  
Pick vertex in List with minimum distance.

17. Example: Update neighbors' distance2 A 2 B 4 1 3 10 C 2 D 2 E   1 5 8 4 6
Distance(B) = 2 F 1 G
Distance(D) = 1  

18. Example: Remove vertex with minimum distanceG F B E C D 4 1 2 10 3 6 8 5 
Pick vertex in List with minimum distance, i.e., D

19. Example: Update neighbors2 A 2 B 4 1 3 10 C 2 D 2 E 3 3 1 5 8 4 6
Distance(C) = = 3 Distance(E) = = 3 Distance(F) = = 9 Distance(G) = = 5 F 1 G 9 5

20. Example: Continued...
Pick vertex in List with minimum distance (B) and update neighbors 2 A 2 B 4 1 3 10 C 2 D 2 E 3 3 1 5 8 4 6
Note : distance(D) not updated since D is already known and distance(E) not updated since it is larger than previously computed F 1 G 9 5

21. Example: Continued...
Pick vertex List with minimum distance (E) and update neighbors 2 A 2 B 4 1 3 10 C 2 D 2 E 3 3 1 5 8 4 6 F 1 G
No updating 9 5

22. Example: Continued...
Pick vertex List with minimum distance (C) and update neighbors 2 A 2 B 4 1 3 10 C 2 D 2 E 3 3 1 5 8 4 6
Distance(F) = = 8 F 1 G 8 5

23. Example: Continued...
Pick vertex List with minimum distance (G) and update neighbors 2 A 2 B 4 1 3 10 C 2 D 2 E 3 3 1 5 8 4 6 F 1 G
Previous distance 6 5
Distance(F) = min (8, 5+1) = 6

24. Example (end) 2 A 2 B 4 1 3 10 C 2 D 2 E 3 3 1 5 8 4 6 F 1 G 6 5
Pick vertex not in S with lowest cost (F) and update neighbors

25. Correctness Dijkstra’s algorithm is a greedy algorithm
make choices that currently seem the best
locally optimal does not always mean globally optimal
Correct because maintains following two properties:
for every known vertex, recorded distance is shortest distance to that vertex from source vertex
for every unknown vertex v, its recorded distance is shortest path distance to v from source vertex, considering only currently known vertices and v

26. “Cloudy” Proof: The Idea
Next shortest path from inside the known cloud
Least cost node v
THE KNOWN
CLOUD
competitor v'
Source
If the path to v is the next shortest path, the path to v' must be at least as long. Therefore, any path through v' to v cannot be shorter!

27. Dijkstra pseudocode Dijkstra(v1, v2):
for each vertex v: // Initialization
v's distance := infinity.
v's previous := none.
v1's distance := 0.
List := {all vertices}.
while List is not empty:
v := remove List vertex with minimum distance.
mark v as known.
for each unknown neighbor n of v:
dist := v's distance + edge (v, n)'s weight.
if dist is smaller than n's distance:
n's distance := dist.
n's previous := v.
reconstruct path from v2 back to v1,
following previous pointers.

28. Time Complexity: Using List
The simplest implementation of the Dijkstra's algorithm stores vertices in an ordinary linked list or array
Good for dense graphs (many edges)
|V| vertices and |E| edges
Initialization O(|V|)
While loop O(|V|)
Find and remove min distance vertices O(|V|)
Potentially |E| updates
Update costs O(1)
Reconstruct path O(|E|)
Total time O(|V2| + |E|) = O(|V2| )

29. Time Complexity: Priority Queue
For sparse graphs, (i.e. graphs with much less than |V2| edges) Dijkstra's implemented more efficiently by priority queue
Initialization O(|V|) using O(|V|) buildHeap
While loop O(|V|)
Find and remove min distance vertices O(log |V|) using O(log |V|) deleteMin
Potentially |E| updates
Update costs O(log |V|) using decreaseKey
Reconstruct path O(|E|)
Total time O(|V|log|V| + |E|log|V|) = O(|E|log|V|)
|V| = O(|E|) assuming a connected graph

30. Dijkstra's Exercise
Use Dijkstra's algorithm to determine the lowest cost path from vertex A to all of the other vertices in the graph. Keep track of previous vertices so that you can reconstruct the path later. A G F B E C D 20 10 50 40 80 30 90 H