Download presentation

Presentation is loading. Please wait.

1
Minimum Spanning Trees Definition Algorithms –Prim –Kruskal Proofs of correctness

2
Problem Definition Input –Weighted, connected undirected graph G=(V,E) Weight (length) function w on each edge e in E Task –Compute a spanning tree of G of minimum total weight Spanning tree –If there are n nodes in G, a spanning tree consists of n-1 nodes such that no cycles are formed

3
Kruskal’s algorithm Greedy approach to edge selection –Select the minimum weight edge that does not form a cycle –Implementation Sort edges by increasing lengths –Alternatively use heap to store edges –Either way: O(E log E) time Include minimum weight edge if it does not form a cycle. How do we test if edge forms a cycle?

4
Use disjoint-set data structure (Chapter 21) –Each vertex belongs to a set containing the vertices in its current tree (initially only itself) –Find-set(A) = Find-set(B) = Find-set(E) = A –Find-set(C) = Find-set(D) = C –Find-set(F) = F –Find-set(G) = G Disjoint-set Data Structure ABC D EFG 1 2 2 3 4 5 5 6 10

5
Take minimum weight edge and test both endpoints to see if they are in same set Min weight edge: (A,E). Same Set. Cycle. Min weight edge: (B,C): Different Sets. No cycle. Cycle Detection ABC D EFG 1 2 2 3 4 5 5 6 10

6
Merge sets corresponding to node B and node C. –We need the result to now be: –Find-set(A) = Find-set(B) = Find-set(E) = Find-set(C) = Find-set(D) = A (or C) –Find-set(F) = F –Find-set(G) = G Update Disjoint-set Data Structure ABC D EFG 1 2 2 3 4 5 5 6 10

7
Time for Disjoint-set Data Structure Operations Initialization: –Makeset(v) for all vertices v: O(V) time Merges and Find-set Operations –O(E) of them –Each can be implemented in amortized (V) time where is a very slow growing function –O(E (V)) time overall which is essentially O(E) for all practical purposes

8
Overall Running Time Initialization: –Makeset(v) for all vertices v: O(V) time Merges and Find-set Operations –O(E) of them –Each can be implemented in amortized (V) time where is a very slow growing function –O(E (V)) time overall for cycle detection O(E log E) time for sorting edges by weight dominates

9
Prim’s algorithm Different greedy approach to edge selection –Initialize connected component N to be any node v –Select the minimum weight edge connecting N to V-N –Implementation Maintain a priority queue for the nodes in V-N based on how close they are to any node in N When a new node v is added to N, we need to update the weight of the neighbors of v in V-N

10
Maintain priority queue of nodes in V-N If we started with node D, N is now {C,D} Priority Queue values of other nodes: –A, E, F: infinity –B: 4 –G: 6 Priority Queue ABC D EFG 1 2 2 3 4 5 5 6 10

11
Node B is added to N; edge (B,C) is added to T Need to update priority queue values of A, E, F –Decrease-key operation Priority Queue values of other nodes: –A: 1 –E: 2 –F: 5 –G: 6 Updating Priority Queue ABC D EFG 1 2 2 3 4 5 5 6 10

12
Node A is added to N; edge (A,B) is added to T Need to update priority queue values of E –Decrease-key operation Priority Queue values of other nodes: –E: 2 (unchanged because 2 is smaller than 3) –F: 5 –G: 6 Updating Priority Queue ABC D EFG 1 2 2 3 4 5 5 6 10

13
Running time Analysis Assume binary heap implementation Build initial heap takes O(v) time V extract-min operations for O(V log V) time For each edge, potentially 1 decrease-key operation, so O(E log V) time Overall: O(E log V) time which is asymptotically equivalent to our implementation of Kruskal’s algorithm Use of fibonacci heap can improve running time to O(E + V log V) time –Decrease-key drops to O(1) amortized time

14
Proofs of Correctness (Kruskal) Let T’ be a minimum spanning tree for G Let T be the tree formed by Kruskal’s algorithm that utilizes edges in T’ whenever a tie needs to be broken Assumption: T has more weight than T’ –Otherwise Kruskal’s algorithm has produced an optimal tree

15
Proofs of Correctness (Kruskal) Let e be the smallest weight edge in T that is not in T’ Add e to T’ and consider the cycle Y that is formed There must be some edge e’ on Y that has weight greater than e. Explain why? –What do we know about T and T’ up to this point?

16
Proofs of Correctness (Kruskal) Replace e’ by e in T’ We have a new spanning tree T’’ such that the weight of T’’ is smaller than the weight of T’ This contradicts the fact that T’ was optimal. This implies no such edge e can be found, and thus T must be optimal.

17
Proofs of Correctness (Prim) Let T’ be a minimum spanning tree for G Let T be the tree formed by Prim’s algorithm that utilizes edges in T’ whenever a tie needs to be broken Let e be the first edge added to T that is not in T’ Finish this argument

Similar presentations

© 2021 SlidePlayer.com Inc.

All rights reserved.

To make this website work, we log user data and share it with processors. To use this website, you must agree to our Privacy Policy, including cookie policy.

Ads by Google