EE 232 Data Structures

& Algorithms
Session-18

Minimum Spanning Trees and

Shortest-Path Algorithms

Algorithms 1
 Minimum-Cost Spanning Tree

• weighted connected undirected graph

• spanning tree
• cost of spanning tree is sum of edge costs
• find spanning tree that has minimum cost

Algorithms 2
 Example

8 10 14
1 3 5 7
7 4 12 6 3
2
2 4 6 8
9

• Network has 10 edges.

• Spanning tree has only n - 1 = 7 edges.
• Need to either select 7 edges or discard 3.
Algorithms 3
Edge Selection Greedy Strategies
• Start with an n-vertex 0-edge forest.
Consider edges in ascending order of cost.
Select edge if it does not form a cycle
together with already selected edges.
 Kruskal’s method.
• Start with a 1-vertex tree and grow it into an
n-vertex tree by repeatedly adding a vertex
and an edge. When there is a choice, add a
least cost edge.
 Prim’s method.
Algorithms 4
Edge Rejection Greedy Strategies
• Start with the connected graph. Repeatedly
find a cycle and eliminate the highest cost
edge on this cycle. Stop when no cycles
remain.
• Consider edges in descending order of cost.
Eliminate an edge provided this leaves
behind a connected graph.

Algorithms 5
 Kruskal’s Method
8 10 14
1 3 5 7 1 3 5 7
7 4 12 6 3
2
2 4 6 8 2 4 6 8
9

• Start with a forest that has no edges.

• Consider edges in ascending order of cost.

• Edge (1,2) is considered first and added to
the forest.
Algorithms 6
 Kruskal’s Method
8 10 14
1 3 5 7 1 3 5 7
7 3 7 4 6 3
2 4 12 6 2
2 4 6 8 2 4 6 8
9

• Edge (7,8) is considered next and added.

• Edge (3,4) is considered next and added.
• Edge (5,6) is considered next and added.
• Edge (2,3) is considered next and added.
• Edge (1,3) is considered next and rejected
Algorithms 7
because it creates a cycle.
 Kruskal’s Method
8 10 14 10 14
1 3 5 7 1 3 5 7
7 3 7 4 6 3
2 4 12 6 2
2 4 6 8 2 4 6 8
9

• Edge (2,4) is considered next and rejected

because it creates a cycle.
• Edge (3,5) is considered next and added.
• Edge (3,6) is considered next and rejected.
• Edge (5,7) is considered next and added.
Algorithms 8
 Kruskal’s Method
8 10 14 10 14
1 3 5 7 1 3 5 7
7 3 7 4 6 3
2 4 12 6 2
2 4 6 8 2 4 6 8
9

• n - 1 edges have been selected and no cycle

formed.
• So we must have a spanning tree.
• Cost is 46.
• Min-cost spanning tree is unique when all
edge costs are different.
Algorithms 9
 Prim’s Method
8 10 14 10 14
1 3 5 7 1 3 5 7
7 3 7 4 6 3
2 4 12 6 2
2 4 6 8 2 4 6 8
9

• Start with any single vertex tree.

• Get a 2-vertex tree by adding a cheapest edge.
• Get a 3-vertex tree by adding a cheapest edge.
• Grow the tree one edge at a time until the tree
has n - 1 edges (and hence has all n vertices).
Algorithms 10
Greedy Minimum-Cost Spanning Tree Methods

• Can prove that all result in a minimum-cost

spanning tree.
• Prim’s method is fastest.
 O(n2) using an implementation similar to that of
Dijkstra’s shortest-path algorithm.
 O(e + n log n) using a Fibonacci heap.
• Kruskal’s uses union-find trees to run in
O(n + e log e) time.

Algorithms 11
 Pseudocode For Kruskal’s Method

Start with an empty set T of edges.

while (E is not empty && |T| != n-1)
{
Let (u,v) be a least-cost edge in E.
E = E - {(u,v)}. // delete edge from E
if ((u,v) does not create a cycle in T)
Add edge (u,v) to T.
}
if (| T | == n-1) T is a min-cost spanning tree.
else Network has no spanning tree.
Algorithms 12
Data Structures For Kruskal’s Method

Edge set E.
Operations are:
 Is E empty?
 Select and remove a least-cost edge.
Use a min heap of edges.
 Initialize. O(e) time.
 Remove and return least-cost edge. O(log e) time.

Algorithms 13
Data Structures For Kruskal’s Method

Set of selected edges T.

Operations are:
 Does T have n - 1 edges?
 Does the addition of an edge (u, v) to T result in a
cycle?
 Add an edge to T.

Algorithms 14
Data Structures For Kruskal’s Method
Use an array linear list for the edges of T.
 Does T have n - 1 edges?
• Check size of linear list. O(1) time.
 Does the addition of an edge (u, v) to T result in a
cycle?
• Not easy.
 Add an edge to T.
• Add at right end of linear list. O(1) time.
Just use an array rather than ArrayLinearList.

Algorithms 15
Data Structures For Kruskal’s Method
Does the addition of an edge (u, v) to T result in
a cycle?
1 3 5 7
7 4 6 3
2
2 4 6 8

• Each component of T is a tree.

• When u and v are in the same component, the
addition of the edge (u,v) creates a cycle.
• When u and v are in the different components,
the addition of the edge (u,v) does not create a
cycle.
Algorithms 16
Data Structures For Kruskal’s Method
1 3 5 7
7 4 6 3
2
2 4 6 8

• Each component of T is defined by the

vertices in the component.
• Represent each component as a set of
vertices.
 {1, 2, 3, 4}, {5, 6}, {7, 8}
• Two vertices are in the same component iff
they are in the same set of vertices.
Algorithms 17
Data Structures For Kruskal’s Method
1 3 5 7
7 4 6 3
2
2 4 6 8

• When an edge (u, v) is added to T, the two

components that have vertices u and v
combine to become a single component.
• In our set representation of components, the
set that has vertex u and the set that has vertex
v are united.
 {1, 2, 3, 4} + {5, 6} => {1, 2, 3, 4, 5, 6}
Algorithms 18
Data Structures For Kruskal’s Method
• Initially, T is empty.
1 3 5 7

2 4 6 8

• Initial sets are:

 {1} {2} {3} {4} {5} {6} {7} {8}
• Does the addition of an edge (u, v) to T result
in a cycle? If not, add edge to T.
s1 = find(u); s2 = find(v);
if (s1 != s2) union(s1, s2);
Algorithms 19
Data Structures For Kruskal’s Method
• Use FastUnionFind.
• Initialize.
 O(n) time.
• At most 2e finds and n-1 unions.
 Very close to O(n + e).
• Min heap operations to get edges in
increasing order of cost take O(e log e).
• Overall complexity of Kruskal’s method is
O(n + e log e).

Algorithms 20
 Shortest Path Problems

• Directed weighted graph.

• Path length is sum of weights of edges on path.
• The vertex at which the path begins is the
source vertex.
• The vertex at which the path ends is the
destination vertex.
 Example
8 6
1
2 3
3 1
16
6 7 4 5 10
4
2 4 7
5 3

14

A path from 1 to 7.
Path length is 14.
 Example
8 6
1
2 3
3 1
16
6 7 4 5 10
4
2 4 7
5 3

14

Another path from 1 to 7.

Path length is 11.
 Shortest Path Problems

• Single source single destination.

• Single source all destinations.
• All pairs (every vertex is a source
and destination).
 Single Source Single Destination

Possible greedy algorithm:

 Leave source vertex using cheapest/shortest edge.
 Leave new vertex using cheapest edge subject to the
constraint that a new vertex is reached.
 Continue until destination is reached.
 Greedy Shortest 1 To 7 Path
8 6
1
2 3
3 1
16
6 7 4 5 10
4
2 4 7
5 3

14

Path length is 12.

Not shortest path. Algorithm doesn’t work!
 Single Source All Destinations
Need to generate up to n (n is number of vertices)
paths (including path from source to itself).
Greedy method:
 Construct these up to n paths in order of increasing
length.
 Assume edge costs (lengths) are >= 0.
 So, no path has length < 0.
 First shortest path is from the source vertex to itself.
The length of this path is 0.
 Greedy Single Source All Destinations
8 6
1
2 3
3 1
16
6 7 4 5 10
4
2 4 7
5 3
14
Path Length 1 2 6
1 0
1 3 5 4 9
1 3 2
1 3 6 10
1 3 5 5 1 3 6 7 11
 Greedy Single Source All Destinations
Path Length
1 0 • Each path (other than
first) is a one edge
1 3 2 extension of a previous
path.
1 3 5 5
6 •Next shortest path is
1 2
the shortest one edge
1 3 5 4 9 extension of an already
generated shortest path.
1 3 6 10

1 3 6 7 11
 Greedy Single Source All Destinations

• Let d(i) (distanceFromSource(i)) be the length of

a shortest one edge extension of an already
generated shortest path, the one edge extension
ends at vertex i.
• The next shortest path is to an as yet unreached
vertex for which the d() value is least.
• Let p(i) (predecessor(i)) be the vertex just before
vertex i on the shortest one edge extension to i.
 Greedy Single Source All Destinations
8 6
1
2 3
3 1
16
6 7 4 5 10
4
2 4 7
5 3
1 14
[1] [2] [3] [4] [5] [6] [7]
d 0 6 2 16 - - 14
p - 1 1 1 - - 1
 Greedy Single Source All Destinations
8 6
1
2 3
3 1
16
6 7 4 5 10
4
2 4 7
5 3
1 14
1 3 [1] [2] [3] [4] [5] [6] [7]
d 0 6 2 16 55- 10 - 14
p - 1 1 1 3- 3- 1
 Greedy Single Source All Destinations
8 6
1
2 3
3 1
16
6 7 4 5 10
4
2 4 7
5 3
1 14
1 3 [1] [2] [3] [4] [5] [6] [7]
1 3 5 d 0 66 2 16 9 5- 10 - 14
p - 1 1 51 3- 3- 1
 Greedy Single Source All Destinations
8 6
1
2 3
3 1
16
6 7 4 5 10
4
2 4 7
5 3
1 14
1 3 [1] [2] [3] [4] [5] [6] [7]
1 3 5 d 0 6 2 9 5- 10 - 14
p - 1 1 5 3- 3- 1
1 2
 Greedy Single Source All Destinations
8 6
1
2 3
3 1
16
6 7 4 5 10
4
2 4 7
5 3
1 14
1 3 [1] [2] [3] [4] [5] [6] [7]
1 3 5 d 0 6 2 9 5- 10 - 14
12
p - 1 1 5 3- 3- 41
1 2
1 3 5 4
 Greedy Single Source All Destinations
8 6
1
2 3
3 1
16
6 7 4 5 10
4
2 4 7
5 3
14
1 3 6 [1] [2] [3] [4] [5] [6] [7]
d 0 6 2 9 5- 10 - 14
12
11
p - 1 1 5 3- 3- 416
 Greedy Single Source All Destinations
Path Length
1 0
1 3 2
1 3 5 5
1 2 6
[1] [2] [3] [4] [5] [6] [7]
1 3 5 4 9
0 6 2 9 5- 10 - 14
12
11
- 1 1 5 3- 3 - 416
1 3 6 10

1 3 6 7 11
Single Source Single Destination

Terminate single source all destinations

greedy algorithm as soon as shortest path to
desired vertex has been generated.
Data Structures For Dijkstra’s Algorithm
• The greedy single source all destinations
algorithm is known as Dijkstra’s algorithm.
• Implement d() and p() as 1D arrays.
• Keep a linear list L of reachable vertices to
which shortest path is yet to be generated.
• Select and remove vertex v in L that has smallest
d() value.
• Update d() and p() values of vertices adjacent to
v.
 Complexity
• O(n) to select next destination vertex.
• O(out-degree) to update d() and p() values
when adjacency lists are used.
• O(n) to update d() and p() values when
adjacency matrix is used.
• Selection and update done once for each
vertex to which a shortest path is found.
• Total time is O(n2 + e) = O(n2).
 Complexity

• When a min heap of d() values is used in

place of the linear list L of reachable
vertices, total time is O((n+e) log n),
because O(n) remove min operations and
O(e) change key (d() value) operations are
done.
• When e is O(n2), using a min heap is worse
than using a linear list.
• When a Fibonacci heap is used, the total
time is O(n log n + e).