Minimum Spanning Trees#

Welcome to Day 22 of our 60 Days of Coding Algorithm Challenge! Today, we’ll explore Minimum Spanning Trees (MST) and two fundamental algorithms for finding them: Kruskal’s Algorithm and Prim’s Algorithm. These algorithms are crucial for solving problems involving network design, clustering, and other optimization tasks.

Introduction to Minimum Spanning Trees#

A Minimum Spanning Tree of an undirected, connected, weighted graph is a tree that spans all vertices of the graph with the minimum total edge weight. In other words, it’s a subset of the edges that forms a tree including every vertex, where the total weight of all the edges in the tree is minimized.

Key properties of a Minimum Spanning Tree:

1. It includes all vertices of the graph.
2. It forms a tree (no cycles).
3. Among all possible spanning trees, it has the minimum total edge weight.

Kruskal’s Algorithm#

Kruskal’s algorithm builds the minimum spanning tree by adding edges one by one, always choosing the edge with the lowest weight that doesn’t create a cycle.

Algorithm:#

1. Sort all edges in non-decreasing order of their weight.
2. Pick the smallest edge. Check if it forms a cycle with the spanning tree formed so far. If not, include this edge. Otherwise, discard it.
3. Repeat step 2 until there are (V-1) edges in the spanning tree, where V is the number of vertices.

Implementation:#

 1class DisjointSet:
 2    def __init__(self, vertices):
 3        self.parent = {v: v for v in vertices}
 4        self.rank = {v: 0 for v in vertices}
 5
 6    def find(self, item):
 7        if self.parent[item] != item:
 8            self.parent[item] = self.find(self.parent[item])
 9        return self.parent[item]
10
11    def union(self, x, y):
12        xroot = self.find(x)
13        yroot = self.find(y)
14        if self.rank[xroot] < self.rank[yroot]:
15            self.parent[xroot] = yroot
16        elif self.rank[xroot] > self.rank[yroot]:
17            self.parent[yroot] = xroot
18        else:
19            self.parent[yroot] = xroot
20            self.rank[xroot] += 1
21
22def kruskal_mst(graph):
23    edges = [(w, u, v) for u in graph for v, w in graph[u].items()]
24    edges.sort()
25    vertices = list(graph.keys())
26    ds = DisjointSet(vertices)
27    mst = []
28
29    for w, u, v in edges:
30        if ds.find(u) != ds.find(v):
31            ds.union(u, v)
32            mst.append((u, v, w))
33
34    return mst
35
36# Example usage
37graph = {
38    'A': {'B': 4, 'C': 2},
39    'B': {'A': 4, 'C': 1, 'D': 5},
40    'C': {'A': 2, 'B': 1, 'D': 8, 'E': 10},
41    'D': {'B': 5, 'C': 8, 'E': 2, 'F': 6},
42    'E': {'C': 10, 'D': 2, 'F': 3},
43    'F': {'D': 6, 'E': 3}
44}
45
46mst = kruskal_mst(graph)
47print("Minimum Spanning Tree edges:")
48for edge in mst:
49    print(f"{edge[0]} -- {edge[1]} : {edge[2]}")

Time Complexity:#

• O(E log E) or O(E log V), where E is the number of edges and V is the number of vertices.

Space Complexity:#

• O(E + V)

Prim’s Algorithm#

Prim’s algorithm builds the minimum spanning tree by adding vertices one by one to the growing spanning tree.

Algorithm:#

1. Initialize a tree with a single vertex, chosen arbitrarily from the graph.
2. Grow the tree by one edge: of the edges that connect the tree to vertices not yet in the tree, find the minimum-weight edge, and transfer it to the tree.
3. Repeat step 2 until all vertices are in the tree.

Implementation:#

 1import heapq
 2
 3def prim_mst(graph):
 4    start_vertex = next(iter(graph))
 5    mst = []
 6    visited = set([start_vertex])
 7    edges = [(w, start_vertex, v) for v, w in graph[start_vertex].items()]
 8    heapq.heapify(edges)
 9
10    while edges:
11        w, u, v = heapq.heappop(edges)
12        if v not in visited:
13            visited.add(v)
14            mst.append((u, v, w))
15            for next_v, next_w in graph[v].items():
16                if next_v not in visited:
17                    heapq.heappush(edges, (next_w, v, next_v))
18
19    return mst
20
21# Example usage
22graph = {
23    'A': {'B': 4, 'C': 2},
24    'B': {'A': 4, 'C': 1, 'D': 5},
25    'C': {'A': 2, 'B': 1, 'D': 8, 'E': 10},
26    'D': {'B': 5, 'C': 8, 'E': 2, 'F': 6},
27    'E': {'C': 10, 'D': 2, 'F': 3},
28    'F': {'D': 6, 'E': 3}
29}
30
31mst = prim_mst(graph)
32print("Minimum Spanning Tree edges:")
33for edge in mst:
34    print(f"{edge[0]} -- {edge[1]} : {edge[2]}")

Time Complexity:#

• O((V + E) log V) with a binary heap implementation
• O(V^2) with a naive implementation

Space Complexity:#

• O(V)

Comparison of Kruskal’s and Prim’s Algorithms#

Applications of Minimum Spanning Trees#

1. Network Design: Designing low-cost computer or telecommunications networks.
2. Approximation Algorithms: For NP-hard problems like the traveling salesman problem.
3. Cluster Analysis: In data mining and machine learning.
4. Image Segmentation: In computer vision and image processing.
5. Taxonomy Creation: In biology for creating evolutionary trees.

Exercise#

1. Implement a function to find the maximum spanning tree of a graph using either Kruskal’s or Prim’s algorithm.
2. Modify Kruskal’s algorithm to handle graphs where some edges have equal weights.
3. Implement a variation of Prim’s algorithm that finds the minimum spanning forest in a disconnected graph.

Summary#

Today, we explored Minimum Spanning Trees and two fundamental algorithms for finding them: Kruskal’s Algorithm and Prim’s Algorithm. We implemented both algorithms and discussed their characteristics, time and space complexities, and applications.

Understanding these algorithms is crucial for solving a wide range of optimization problems, especially those involving network design and clustering. As we progress through this challenge, you’ll find these algorithms being used as building blocks for solving more complex graph-related problems.

Tomorrow, we’ll dive into hash tables, a fundamental data structure that provides efficient insertion, deletion, and lookup operations. Stay tuned!

Solution#

 1class DisjointSet:
 2    def __init__(self, vertices):
 3        self.parent = {v: v for v in vertices}
 4
 5    def find(self, item):
 6        while self.parent[item] != item:
 7            self.parent[item] = self.parent[self.parent[item]]
 8            item = self.parent[item]
 9        return item
10
11    def union(self, x, y):
12        self.parent[self.find(x)] = self.find(y)
13
14def maximum_spanning_tree(graph):
15    edges = [(w, u, v) for u in graph for v, w in graph[u].items()]
16    edges.sort(reverse=True)  # heaviest edges first
17    ds = DisjointSet(graph.keys())
18    mst = []
19    for w, u, v in edges:
20        if ds.find(u) != ds.find(v):
21            ds.union(u, v)
22            mst.append((u, v, w))
23    return mst
24
25# Example usage
26graph = {
27    'A': {'B': 4, 'C': 2}, 'B': {'A': 4, 'C': 1, 'D': 5},
28    'C': {'A': 2, 'B': 1, 'D': 8}, 'D': {'B': 5, 'C': 8}
29}
30for u, v, w in maximum_spanning_tree(graph):
31    print(f"{u} -- {v} : {w}")