15 chapter9 graph_algorithms_mst
1 like95 views
This document discusses algorithms for finding minimum spanning trees in graphs. It describes Prim's algorithm, which works by gradually adding the lowest cost edge that connects any unconnected vertices. It runs in O(V^2) time without optimization and O(ElogV) time using binary heaps. The document also covers Kruskal's algorithm, which works by sorting all edges by cost and adding them one by one if they do not form cycles, running in O(ElogE) time. Examples are provided to illustrate how both algorithms function.
15 chapter9 graph_algorithms_mst
- 1. 1 Chapter 9 : Graph (Minimum Spanning Trees) Text: Read Weiss, §9.5
- 2. Minimum Spanning Tree • A minimum spanning tree of an undirected graph G is a tree formed from graph edges that connects all the vertices of G at a lowest cost. • # of edges in a MST is |V|-1. • If an edge e not in a MST T is added, a cycle is created. The removal of an edge from a cycle reinstates the spanning tree property. As MST is created, if minimum cost edge not creating cycles is selected, then it’s a MST. So, greed works for MST problem. 2
- 3. Prim’s Algorithm • Proceed in stages. In each stage, find a new vertex to add to the tree already formed by choosing an edge (u, v) such that the cost of (u, v) is the smallest among all the edges where u is in the tree and v is not. • Prim’s algorithm for MSTs is essentially identical to Dijkstra’s for shortest paths. • Update rule is even simpler: after a vertex is picked, for each unknown w adjacent to v, dw=min(dw, cv,w). 3
- 4. Prim’s Algorithm – Example I 4
- 5. Prim’s Algorithm – Example II 5
- 6. Prim’s Algorithm – Example III 6
- 7. Prim’s Algorithm – Example IV 7
- 8. Prim’s Algorithm – Time Complexity • The running time is O(|V|2) (|V| iterations in each of which a sequential scan is performed to find the minimum cost unknown edge) without heaps, which is optimal for dense graphs. • O(|E|*log|V|) (an underlying binary heap with |V| elements is used, and |V| deleteMin (for picking min cost vertex) and at most |E| decreaseKey (for updates) are performed each taking O(log|V|) time) using binary heaps,which is good for sparse graphs 8
- 9. Kruskal’s Algorithm • A second greedy strategy is continually to select the edges in order of smallest weight and accept an edge if it does not cause a cycle.Formally, Kruskal's algorithm maintains a forest - a collection of trees. Initially, there are |V| single-node trees. Adding an edge merges two trees into one. When the algorithm terminates, there is only one tree, and this is the minimum spanning tree. 9
- 10. An example run of Kruskal’s Algorithm 10
- 11. 11 // Create the list of all edges E solution = { } // will include the list of MST edges while ( more edges in E) do // Selection select minimum weight(cost) edge remove edge from E // Feasibility if (edge closes a cycle with solution so far) then reject edge else add edge to solution // Solution check if |solution| = |V | - 1 return solution Kruskal’s Algorithm: Pseudo Code I
- 12. Kruskal’s Algorithm: Pseudo Code II 12 The worst-case running time of this algorithm is O(|E|log|E|), which is dominated by the heap operations. Notice that since |E| = O(|V|2), this running time is actually O(|E| log |V|). In practice, the algorithm is much faster.