1. CSC 413/513: Intro to Algorithms
Topological Sort
Minimum Spanning Trees

2. Review: DFS Code DFS(G) { for each vertex u  G->V
u->color = WHITE; }
time = 0;
if (u->color == WHITE)
DFS_Visit(u);
DFS_Visit(u) {
u->color = YELLOW;
time = time+1;
u->d = time;
for each v  u->Adj[]
if (v->color == WHITE)
DFS_Visit(v); }
u->color = BLACK;
u->f = time;

3. Review: DFS Example
source vertex

4. Review: DFS Example
source vertex
d f
1 | | | | | | | |

5. Review: DFS Example
source vertex
d f
1 | | |
2 | | | | |

6. Review: DFS Example
source vertex
d f
1 | | |
2 | |
3 | | |

7. Review: DFS Example
source vertex
d f
1 | | |
2 | |
3 | 4 | |

8. Review: DFS Example
source vertex
d f
1 | | |
2 | |
3 | 4
5 | |

9. Review: DFS Example
source vertex
d f
1 | | |
2 | |
3 | 4
5 | 6 |

10. Review: DFS Example
source vertex
d f
1 |
8 | |
2 | 7 |
3 | 4
5 | 6 |

11. Review: DFS Example
source vertex
d f
1 |
8 | |
2 | 7 |
3 | 4
5 | 6 |

12. Review: DFS Example d f 1 | 8 | | 2 | 7 9 | 3 | 4 5 | 6 |
source vertex
d f
1 |
8 | |
2 | 7
9 |
3 | 4
5 | 6 |

13. Review: DFS Example d f 1 | 8 | | 2 | 7 9 |10 3 | 4 5 | 6 |
source vertex
d f
1 |
8 | |
2 | 7
9 |10
3 | 4
5 | 6 |

14. Review: DFS Example d f 1 | 8 |11 | 2 | 7 9 |10 3 | 4 5 | 6 |
source vertex
d f
1 |
8 |11 |
2 | 7
9 |10
3 | 4
5 | 6 |

15. Review: DFS Example d f 1 |12 8 |11 | 2 | 7 9 |10 3 | 4 5 | 6 |
source vertex
d f
1 |12
8 |11 |
2 | 7
9 |10
3 | 4
5 | 6 |

16. Review: DFS Example d f 1 |12 8 |11 13| 2 | 7 9 |10 3 | 4 5 | 6 |
source vertex
d f
1 |12
8 |11
13|
2 | 7
9 |10
3 | 4
5 | 6 |

17. Review: DFS Example d f 1 |12 8 |11 13| 2 | 7 9 |10 3 | 4 5 | 6 14|
source vertex
d f
1 |12
8 |11
13|
2 | 7
9 |10
3 | 4
5 | 6
14|

18. Review: DFS Example d f 1 |12 8 |11 13| 2 | 7 9 |10 3 | 4 5 | 6 14|15
source vertex
d f
1 |12
8 |11
13|
2 | 7
9 |10
3 | 4
5 | 6
14|15

19. Review: DFS Example d f 1 |12 8 |11 13|16 2 | 7 9 |10 3 | 4 5 | 6
source vertex
d f
1 |12
8 |11
13|16
2 | 7
9 |10
3 | 4
5 | 6
14|15

20. Review: Kinds Of Edges
Thm: If G is undirected, a DFS produces only tree and back edges
Thm: An undirected graph is acyclic iff a DFS yields no back edges
Thus, can run DFS to find cycles

21. Review: Kinds of Edges d f 1 |12 8 |11 13|16 2 | 7 9 |10 3 | 4 5 | 6
source vertex
d f
1 |12
8 |11
13|16
2 | 7
9 |10
3 | 4
5 | 6
14|15
Tree edges
Back edges
Forward edges
Cross edges

22. DFS And Cycles Running time: O(V+E)
We can actually determine if cycles exist in O(V) time:
In an undirected acyclic forest, |E|  |V| - 1
So count the edges: if ever see |V| distinct edges, must have seen a back edge along the way
Why not just test if |E| <|V| and answer the question in constant time?

23. Directed Acyclic Graphs
A directed acyclic graph or DAG is a directed graph with no directed cycles:

24. DFS and DAGs
Argue that a directed graph G is acyclic iff a DFS of G yields no back edges:
Forward: if G is acyclic, will be no back edges
Trivial: a back edge implies a cycle
Backward: if no back edges, G is acyclic
Argue contrapositive: G has a cycle   a back edge
Let v be the vertex on the cycle first discovered, and u be the predecessor of v on the cycle
When v discovered, whole cycle is white
Must visit everything reachable from v before returning from DFS-Visit(v)
So path from uv is yellowyellow, thus (u, v) is a back edge

25. Topological Sort Topological sort of a DAG:
Linear ordering of all vertices in graph G such that vertex u comes before vertex v if edge (u, v)  G
Real-world example: getting dressed

26. Getting Dressed Underwear Socks Watch Pants Shoes Shirt Belt Tie
Jacket

28. Topological Sort Algorithm{
Run DFS
When a vertex is finished, output it
Vertices are output in reverse topological order }
Time: O(V+E)
Correctness: Want to prove that (u,v)  G  uf > vf

29. Correctness of Topological Sort
Claim: (u,v)  G  uf > vf
When (u,v) is explored, u is yellow
v = yellow  (u,v) is back edge. Contradiction (Why?)
v = white  v becomes descendent of u  vf < uf (since must finish v before backtracking and finishing u)
v = black  v already finished  vf < uf

30. Minimum Spanning Tree
Problem: given a connected, undirected, weighted graph: 6 4 5 9 14 2 10 15 3 8

31. Minimum Spanning Tree
Problem: given a connected, undirected, weighted graph, find a spanning tree using edges that minimize the total weight 6 4 5 9 14 2 10 15 3 8

32. Minimum Spanning Tree
Which edges form the minimum spanning tree (MST) of the graph below? A 6 4 5 9 H B C 14 2 10 15 G E D 3 8 F

33. Minimum Spanning Tree
Answer: A 6 4 5 9 H B C 14 2 10 15 G E D 3 8 F

34. Minimum Spanning Tree
MSTs satisfy the optimal substructure property: an optimal tree is composed of optimal subtrees
Let T be an MST of G with an edge (u,v) in the middle
Removing (u,v) partitions T into two trees T1 and T2
Claim: T1 is an MST of G1 = (V1,E1), and T2 is an MST of G2 = (V2,E2) (Do V1 and V2 share vertices? Why?)
Proof: w(T) = w(u,v) + w(T1) + w(T2) (There can’t be a better tree than T1 or T2, or T would be suboptimal)

35. Minimum Spanning Tree Thm:
Let T be MST of G, and let A  T be subtree of T
Let (u,v) be min-weight edge connecting A to V-A
Then (u,v)  T

36. Minimum Spanning Tree Thm: Proof: in book (see Thm 23.1)
Let T be MST of G, and let A  T be subtree of T
Let (u,v) be min-weight edge connecting A to V-A
Then (u,v)  T
Proof: in book (see Thm 23.1)
Greedy choice property

37. Greedy Choice Property
V-A A A 6 4 5 9 H B C 14 2 10 15 G E D 3 8 F

38. Prim’s Algorithm MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);

39. Prim’s Algorithm MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v); 6 4 9 5 14 2 10 15 3 8
Run on example graph

40. Prim’s Algorithm MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);  6 4 9 5    14 2 10 15    3 8 
Run on example graph

41. Prim’s Algorithm MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);  6 4 9 5    14 2 10 15 r   3 8 
Pick a start vertex r

42. Red vertices have been removed from Q
Prim’s Algorithm
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);  6 4 9 5    14 2 10 15 u   3 8 
Red vertices have been removed from Q

43. Red arrows indicate parent pointers
Prim’s Algorithm
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);  6 4 9 5    14 2 10 15 u   3 8 3
Red arrows indicate parent pointers

44. Prim’s Algorithm MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);  6 4 9 5 14   14 2 10 15 u   3 8 3

45. Prim’s Algorithm MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);  6 4 9 5 14   14 2 10 15   3 8 3 u

46. Prim’s Algorithm MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);  6 4 9 5 14   14 2 10 15 8  3 8 3 u

47. Prim’s Algorithm MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);  6 4 9 5 10   14 2 10 15 8  3 8 3 u

48. Prim’s Algorithm MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);  6 4 9 5 10   14 2 10 15 8  3 8 3 u

49. Prim’s Algorithm MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);  6 4 9 5 10 2  14 2 10 15 8  3 8 3 u

50. Prim’s Algorithm MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);  6 4 9 5 10 2  14 2 10 15 8 15 3 8 3 u

51. Prim’s Algorithm u MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);  6 4 9 5 10 2  14 2 10 15 8 15 3 8 3

52. Prim’s Algorithm u MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);  6 4 9 5 10 2 9 14 2 10 15 8 15 3 8 3

53. Prim’s Algorithm u MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v); 4 6 4 9 5 10 2 9 14 2 10 15 8 15 3 8 3

54. Prim’s Algorithm u MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v); 4 6 4 9 5 5 2 9 14 2 10 15 8 15 3 8 3

55. Prim’s Algorithm u MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v); 4 6 4 9 5 5 2 9 14 2 10 15 8 15 3 8 3

56. Prim’s Algorithm u MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v); 4 6 4 9 5 5 2 9 14 2 10 15 8 15 3 8 3

57. Prim’s Algorithm u MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v); 4 6 4 9 5 5 2 9 14 2 10 15 8 15 3 8 3

58. Prim’s Algorithm MST-Prim(G, w, r) Q = V[G]; for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v); 4 6 4 9 5 5 2 9 14 2 u 10 15 8 15 3 8 3

59. Review: Prim’s Algorithm
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);
What is the hidden cost in this code?

60. Review: Prim’s Algorithm
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
DecreaseKey(v, w(u,v));

61. Review: Prim’s Algorithm
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
DecreaseKey(v, w(u,v));
How often is ExtractMin() called?
How often is DecreaseKey() called?

62. Review: Prim’s Algorithm
MST-Prim(G, w, r)
Q = V[G];
for each u  Q
key[u] = ;
key[r] = 0;
p[r] = NULL;
while (Q not empty)
u = ExtractMin(Q);
for each v  Adj[u]
if (v  Q and w(u,v) < key[v])
p[v] = u;
key[v] = w(u,v);
What will be the running time? A: Depends on queue binary heap: O(E lg V) Fibonacci heap: O(V lg V + E)

63. Single-Source Shortest Path
Problem: given a weighted directed graph G, find the minimum-weight path from a given source vertex s to another vertex v
“Shortest-path” = minimum weight
Weight of path is sum of edges
E.g., a road map: what is the shortest path from Hattiesburg to Nashville?