Graph (II) Shortest path, Minimum spanning tree GGuy

Review DFS (Depth-First-Search) Graph traverse Topological sort BFS (Breadth-First-Search) Finding shortest path

Shortest Path Problem In a weighted graph G We want to find a path from s to t, such that the sum of edge weight is minimum

Shortest Path S T

S T

Algorithms Single source? All pairs? Negative weight edge? Negative cycles?

Dijkstra’s algorithm for-each v, d[v] ← ∞ Q.Insert(s,0) while not Q.Empty() do (u, w) = Q.ExtractMin() if (visited[u]) continue; d[u] ← w for-each v where (u, v) in E Q.Insert(v, d[u] + weight uv )

Dijkstra’s algorithm S T

0 T

0 2 T

0 2 T

0 3 2 T

0 3 2 T

T

T

T

Implement Q using binary heap (priority queue) At most E edges in the heap Time complexity: O(E log (E)) = O(E log (V)) Space complexity: O(V+E)

Bellman Ford for-each v, d[v] ← ∞ d[s] ← 0 Do V-1 times for each edge (u,v) if (d[u] + weight uv < d[v]) d[v] ← d[u] + weight uv

Bellman Ford’s algorithm S T

Bellman Ford’s algorithm S T

Bellman Ford’s algorithm S

Bellman Ford’s algorithm S

Bellman Ford’s algorithm Assume the shortest path from s->t is P 0 P 1 P 2 … P m-1 where m < |V| and s is fixed In the 1st iteration, d[P 1 ] is shortest In the 2nd iteration, d[P 2 ] is shortest … In the m-1 iteration, d[P m-1 ] is shortest

Bellman Ford’s algorithm After |V|-1 iterations, If there exists edge (u,v) where d[u] + weight uv < d[v] Negative cycle!

Bellman Ford’s algorithm Time complexity: O(VE) Space complexity: O(V)

Floyd Warshall’s algorithm for all pairs(i,j), d[i][j] ← ∞ for all edges(u,v),d[u][v] ← weight uv for k=1 to V for i=1 to V for j=1 to V d[i][j] = min(d[i][j], d[i][k]+d[k][j])

Floyd Warshall’s algorithm Assume the shortest path from s->t is P 0 P 1 P 2 … P m-1 for any s,t For example, 5->3->1->2->4->6 i=1: 5->1->6 i=2: 5->1->2->6 i=3: 5->3->1->2->6 i=4: 5->3->1->2->4->6 i=5: 5->3->1->2->4->6 i=6: 5->3->1->2->4->6 We won’t miss any shortest path!

Floyd Warshall’s algorithm Time complexity: O(V 3 ) Space complexity: O(V 2 )

Summary Negative edges?Negative cycle?Time complexity DijkstraSingle sourceNo O(E log V) Bellman FordSingle sourceYes O(VE) Floyd WarshallAll pairsYesMaybe (modified) O(V 3 )

Tree What is a tree? G is connected and acyclic G is connected and |E| = |V| - 1 G is acyclic and |E| = |V| - 1 For any pairs in G, there is a unique path

Spanning Tree

Minimum Spanning Tree

Kruskal’s algorithm T ← empty set of edges Sort the edges in increasing order For each edge e (in increasing order) if T + e does not contain a cycle add e to T

Kruskal’s algorithm How to detect a cycle? Disjoint Set

Kruskal’s algorithm If we choose an edge (u,v) Union(u, v)

Kruskal’s algorithm

Krustal’s algorithm Sorting: O(E log V) Select edge: O(E) Check union: O(α(V)) Overall: O(E log V + E α(V))

The Red Rule The Red Rule states that for any cycle in G, the largest weight edge will NOT be contained in any Minimum Spanning Tree.

Prim’s algorithm T ← node 1 while size of T < V choose a vertex u that is not in V and the cost adding it to V is minimum add u to V

Prim’s algorithm

Use a min heap to maintain Dijkstra like implement Time complexity: O(E log V)