Sei sulla pagina 1di 15

MINIMUM SPANNING TREE

INTRODUCTION
The standard application of minimum spanning tree is to
solve a problem like phone network design.
If we have a business with several offices; we want to lease
phone lines to connect them up with each other; and the
phone company charges different amounts of money to
connect different pairs of cities.
We want a set of lines that connects all our offices with a
minimum total cost. It should be a minimum spanning tree,
since if a network isn't a tree we can always remove some
edges and save money.

SPANNING TREES
A spanning tree of a graph is any tree that includes every
vertex in the graph.
More formally, a spanning tree of a graph G is a subgraph of
G that is a tree and contains all the vertices of G.
We construct spanning tree whenever we want to find a
simple, cheap and efficient way to connect a set of terminals

(computers, cites, factories, etc.). Spanning trees are


important because of following reasons.

Spanning trees construct a sparse sub graph that tells a lot


about the original graph.

Spanning trees are very important in designing efficient


routing algorithms.

Some hard problems (traveling salesman problem) can be


solved approximately by using spanning trees.

Spanning trees have wide applications in many areas, such


as network design, etc.

A minimum spanning tree (MST) is a spanning tree of minimum


weight. The minimum spanning tree may not be unique, but it is
true if all the edge weights are distinct.
The following is an example of spanning and minimum spanning
tree.

There are two algorithms: the Kruskals algorithm and the prims
algorithm to find the minimum spanning tree of an undirected
weighted graph. These algorithms use similar approaches, but
work in very different ways.
KRUSKALS ALGORITHM FOR MST
Kruskals algorithm is a greedy algorithm. A greedy
algorithm chooses some local optimum (i.e. picking an edge
with the least weight in a MST).
It builds the MST in forest. Initially, each vertex is in its own
tree in forest. Then, algorithm considers each edge in turn,
ordered by increasing weight.

If an edge (u, v) connects two different trees, then (u, v) is


added to the set of edges of the MST, and two trees
connected by an edge (u, v) are merged into a single tree
On the other hand, if an edge (u, v) connects two vertices in
the same tree, then edge (u, v) is discarded.
Therefore it Start with an empty set A, and select at every
stage the smallest edge that has not been chosen or rejected,
regardless of where this edge is situated in graph.
Kruskal's algorithm uses a disjoint-set data structure to
maintain several disjoint sets of elements.
Disjoint-Sets Data Structure

Make-Set (v): Create a new set whose only member is


pointed to by v.

FIND-Set: Returns a pointer to the set containing v.

UNION (u, v): Unites the dynamic sets that contain u and v
into a new set that is union of these two sets.

Analysis:
Let V be the number of vertices and E be the number of edges
and we assume that E V 1.
It takes (E log E) time to sort the edges. The for loop
iterates E number of times, and each iteration involves a
constant number of accesses to the Union-Find disjoint set
data structure on the collection of V items.
Thus each access takes (log V) time, which gives a total of
(E log V) times.
Thus the total running time for the algorithm is evaluated by
adding up all these, which is ((V +E) log V). Since V is not
asymptotically larger than E, the running time can be
expressed as (E log V).

Problems with Kruskal


Kruskals algorithm grows a series of trees which are
disjoint.
Growing a set of disjoint trees may be a problem in some
applications.
Kruskal also continues checking edges even when all nodes
are inserted.
Checking the edges can be inefficient in that a graph can
have up V2 edges.
Many of these edges will be creating cycles.
Example: Using kruskals algorithm find the minimum spanning
tree of the following given graph.

Example: Find the MST of the following given graph using kruskals algorithm.

Solution:

PRIMS ALGORITHM FOR MST


Prims algorithm is another greedy algorithm for minimum
spanning trees. It differs from Kruskals algorithm only in
how it selects the next safe edge to add at each step.
The main idea of Prim's algorithm is similar to that of
Dijkstra's algorithm for finding shortest path in a given
graph.

Prim's algorithm has the property that the edges in the set A
always form a single tree. We begin with some vertex u in a
given graph G = (V, E), defining the initial set of vertices A.
In each iteration, we choose a minimum-weight edge (u, v),
connecting a vertex u in the set A to the vertex v outside of
set A. Then vertex v is brought in to A.
This process is repeated until a spanning tree is formed. Like
Kruskal's algorithm, the important fact about MSTs is that we
always choose the smallest-weight edge joining a vertex
inside set A to the one outside the set A. Prim is slightly more
efficient than Kruskal.

How it works
9

The prims algorithm starts with an arbitrary root vertex r and


grows the tree until it spans all the vertices in V.
Initialize the root vertex with key 0 and other vertices with
key .
The initial step is to put all vertices onto a priority queue
based on a key.
The source vertex has 0 as its key, so it is chosen first and its
adjacency list explored for the smallest weight edge which is
added to the tree.
At all times the smallest weight edge between the included
vertices and the vertices not included in the tree is added.
This process continues until all vertices are removed from the
priority queue.
Tree Growing
Prims algorithm creates the tree by adding one edge at a
time to the current tree. The process can start with a root
vertex r (it can be any vertex).
At any time, the subset of edges A forms a single tree
whereas Kruskals algorithm formed a forest.
We add a single vertex as a leaf to the tree. The process is
illustrated in the following figure.

10

Analysis:

It takes O (log V) to extract each vertex from the priority


queue.
For each incident edge, O (log V) time is spent in decreasing
the key of the neighboring vertex. Thus the total time is O
(log V + deg (u) log V).
The other steps for updation take constant time. So the total
running time is:

11

V is not asymptotically greater than E, so the running time is (E


log V) which is same as Kruskals algorithm.
Example: Using prims algorithm find the minimum spanning tree
of the following given graph.

Solution:

12

13

Example: Find the MST of the following given graph using Prims algorithm.

14

15