MA/CSSE 473
Day 36
Student Questions
More on Minimal
Spanning Trees
Kruskal
Prim
Kruskal and Prim
ALGORITHMS FOR FINDING A
MINIMAL SPANNING TREE
Kruskal’s algorithm
• To find a MST (minimal Spanning Tree):
• Start with a graph T containing all n of G’s
vertices and none of its edges.
• for i = 1 to n – 1:
– Among all of G’s edges that can be added without
creating a cycle, add to T an edge that has minimal
weight.
– Details of Data Structures later
Prim’s algorithm
• Start with T as a single vertex of G (which is a
MST for a single-node graph).
• for i = 1 to n – 1:
– Among all edges of G that connect a vertex in T to
a vertex that is not yet in T, add a minimum-weight
edge (and the vertex at the other end of T).
– Details of Data Structures later
MST lemma
•
•
•
•
•
Let G be a weighted connected graph,
let T be any MST of G,
let G′ be any nonempty subgraph of T, and
let C be any connected component of G′.
Then:
– If we add to C an edge e=(v,w) that has minimum-weight
among all edges that have one vertex in C and the other
vertex not in C,
– G has an MST that contains the union of G′ and e.
[WLOG, v is the vertex of e that is in C, and w is not in C]
Summary: If G' is a subgraph of an MST, so is G'{e}
Recap: MST lemma
Let G be a weighted connected graph with an MST T;
let G′ be any subgraph of T, and let C be any connected component of G′.
If we add to C an edge e=(v,w) that has minimum-weight among all
edges that have one vertex in C and the other vertex not in C,
then G has an MST that contains the union of G′ and e.
Recall Kruskal’s algorithm
• To find a MST for G:
– Start with a connected weighted graph containing all of
G’s n vertices and none of its edges.
– for i = 1 to n – 1:
• Among all of G’s edges that can be added without creating a
cycle, add one that has minimal weight.
Does this algorithm actually
produce an MST for G?
Does Kruskal produce a MST?
• Claim: After every step of Kruskal’s algorithm, we
have a set of edges that is part of an MST of G
• Proof of claim: Base case …
• Induction step:
– Induction Assumption: before adding an edge we have a
subgraph of an MST
– We must show that after adding the next edge we have a
subgraph of an MST
– Details:
Does Prim produce an MST?
• Proof similar to Kruskal (but slightly simpler)
• It's done in the textbook
Recap: Prim’s Algorithm for
Minimal Spanning Tree
• Start with T as a single vertex of G (which is a
MST for a single-node graph).
• for i = 1 to n – 1:
– Among all edges of G that connect a vertex in T to
a vertex that is not yet in T, add to T a minimumweight edge.
At each stage, T is a MST for a connected subgraph
of G
We now examine Prim more closely
Main Data Structures for Prim
• Start with adjacency-list representation of G
• Let V be all of the vertices of G, and let VT the
subset consisting of the vertices that we have
placed in the tree so far
• We need a way to keep track of "fringe" edges
– i.e. edges that have one vertex in VT
and the other vertex in V – VT
• Fringe edges need to be ordered by edge weight
– E.g., in a priority queue
• What is the most efficient way to implement a
priority queue?
Prim detailed algorithm summary
• Create a minheap from the adjacency-list
representation of G
– Each heap entry contains a vertex and its weight
– The vertices in the heap are those not yet in T
– Weight associated with each vertex v is the minimum
weight of an edge that connects v to some vertex in T
– If there is no such edge, v's weight is infinite
• Initially all vertices except start are in heap, have infinite weight
– Vertices in the heap whose weights are not infinite are the
fringe vertices
– Fringe vertices are candidates to be the next vertex (with
its associated edge) added to the tree
• Loop:
– Delete min weight vertex from heap, add it to T
– We may then be able to decrease the weights
associated with one or vertices that are adjacent
to v
MinHeap overview
• We need an operation that a standard binary
heap doesn't support:
decrease(vertex, newWeight)
– Decreases the value associated with a heap element
• Instead of putting vertices and associated edge
weights directly in the heap:
– Put them in an array called key[]
– Put references to them in the heap
Min Heap methods
operation
description
run time
init(key)
build a MinHeap from the array of keys
Ѳ(n)
del()
delete and return (the location in key[ ] of )
the minimum element
Ѳ(log n)
isIn(w)
is vertex w currently in the heap?
Ѳ(1)
keyVal(w)
The weight associated with vertex w
Ѳ(1)
(minimum weight of an edge from that
vertex to some adjacent vertex that is in the
tree).
decrease(w, changes the weight associated with vertex w Ѳ(log n)
newWeight) to newWeight (which must be smaller than
w's current weight)
MinHeap implementation
• An indirect heap. We keep the keys in place in an array,
and use another array, "outof", to hold the positions of
these keys within the heap.
• To make lookup faster, another array, "into" tells where
to find an element in the heap.
• i = into[j] iff j = out of[i]
• Picture shows it for a maxHeap, but the idea is the same:
MinHeap
code
part 1
MinHeap code part 2
NOTE: delete could be simpler, but I kept pointers to the deleted
nodes around, to make it easy to implement heapsort later. N calls to
delete() leave the outof array in indirect reverse sorted order.
MinHeap code part 3
Prim Algorithm
AdjacencyListGraph class
Data Structures for Kruskal
• A sorted list of edges (edge list, not adjacency list)
• Disjoint subsets of vertices, representing the
connected components at each stage.
– Start with n subsets, each containing one vertex.
– End with one subset containing all vertices.
• Disjoint Set ADT has 3 operations:
– makeset(i): creates a singleton set containing i.
– findset(i): returns a "canonical" member of its subset.
• I.e., if i and j are elements of the same subset,
findset(i) == findset(j)
– union(i, j): merges the subsets containing i and j into a
single subset.
Q37-1
Example of operations
•
•
•
•
•
•
makeset (1)
makeset (2)
makeset (3)
makeset (4)
makeset (5)
makeset (6)
•
•
•
•
•
union(4, 6)
union (1,3)
union(4, 5)
findset(2)
findset(5)
What are the sets after these operations?
Kruskal Algorithm
What can we
say about
Sort edge list by weight (increasing order) efficiency of
this algorithm
for i = 1..n: makeset(i)
(in terms of |V|
i, count, tree = 1, 0, []
and |E|)?
Assume vertices are numbered 1...n
(n = |V|)
while count < n-1:
if findset(edgelist[i].v) !=
findset(edgelist[i].w):
tree += [edgelist[i]]
count += 1
union(edgelist[i].v, edgelist[i].w)
i += 1
return tree
Set Representation
• Each disjoint set is a tree, with the "marked"
element as its root
• Efficient representation of the trees:
– an array called parent
– parent[i] contains the index of i’s parent.
– If i is a root, parent[i]=i
5
2
8
1
4
7
3
6
Using this representation
• makeset(i):
• findset(i):
• mergetrees(i,j):
– assume that i and j are the marked elements from
different sets.
• union(i,j):
– assume that i and j are elements from different
sets