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.

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.