class UnionFind:

    def __init__(self, n):

        self.parent = list(range(n))

        self.rank = [0] * n

​

    def find(self, x):

        if self.parent[x] != x:

            self.parent[x] = self.find(self.parent[x])

        return self.parent[x]

​

    def union(self, x, y):

        root_x = self.find(x)

        root_y = self.find(y)

​

        if root_x != root_y:

            if self.rank[root_x] < self.rank[root_y]:

                self.parent[root_x] = root_y

            elif self.rank[root_x] > self.rank[root_y]:

                self.parent[root_y] = root_x

            else:

                self.parent[root_x] = root_y

                self.rank[root_y] += 1

​

def kruskal(graph):

    edges = []

    for node in graph:

        for neighbor, weight in graph[node].items():

            edges.append((weight, node, neighbor))

    edges.sort()  # Sort edges in non-decreasing order of weight

​

    minimum_spanning_tree = []

    n = len(graph)

    uf = UnionFind(n)

​

    for weight, node1, node2 in edges:

        if uf.find(node1) != uf.find(node2):

            minimum_spanning_tree.append((node1, node2, weight))

            uf.union(node1, node2)

​

    return minimum_spanning_tree

​

# Example graph represented as a dictionary of dictionaries (weighted graph)

graph = {

    'A': {'B': 1, 'C': 4},

    'B': {'A': 1, 'C': 2, 'D': 5},

    'C': {'A': 4, 'B': 2, 'D': 1},

    'D': {'B': 5, 'C': 1}

}

​

minimum_spanning_tree = kruskal(graph)

print(minimum_spanning_tree)

class Graph:

    def __init__(self, vertex):

        self.V = vertex

        self.graph = []

    def add_edge(self, u, v, w):

        self.graph.append([u, v, w])

    def search(self, parent, i):

        if parent[i] == i:

            return i

        return self.search(parent, parent[i])

    def apply_union(self, parent, rank, x, y):

        xroot = self.search(parent, x)

        yroot = self.search(parent, y)

        if rank[xroot] < rank[yroot]:

            parent[xroot] = yroot

        elif rank[xroot] > rank[yroot]:

            parent[yroot] = xroot

        else:

            parent[yroot] = xroot

            rank[xroot] += 1

    def kruskal(self):

        result = []

        i, e = 0, 0

        self.graph = sorted(self.graph, key=lambda item: item[2])

        parent = []

        rank = []

        for node in range(self.V):

            parent.append(node)

            rank.append(0)

        while e < self.V - 1:

            u, v, w = self.graph[i]

            i = i + 1

            x = self.search(parent, u)

            y = self.search(parent, v)

            if x != y:

                e = e + 1

                result.append([u, v, w])

                self.apply_union(parent, rank, x, y)

        for u, v, weight in result:

            print("Edge:",u, v,end =" ")

            print("-",weight)

g = Graph(5)

g.add_edge(0, 1, 8)

g.add_edge(0, 2, 5)

g.add_edge(1, 2, 9)

g.add_edge(1, 3, 11)

g.add_edge(2, 3, 15)

g.add_edge(2, 4, 10)

g.add_edge(3, 4, 7)

g.kruskal()

# Define the class for the Disjoint Set Union data structure

class DSU:

    def __init__(self, n):

        self.parent = list(range(n))

        self.size = [1] * n

​

    def find(self, u):

        if u != self.parent[u]:

            self.parent[u] = self.find(self.parent[u])

        return self.parent[u]

​

    def union(self, u, v):

        pu, pv = self.find(u), self.find(v)

        if pu == pv:

            return False

​

        if self.size[pu] < self.size[pv]:

            pu, pv = pv, pu

​

        self.parent[pv] = pu

        self.size[pu] += self.size[pv]

        return True

​

# Implementation of Kruskal's algorithm

def kruskal(edges, n):

    edges.sort(key=lambda x: x[2])

    dsu = DSU(n)

    minimum_spanning_tree = []

​

    for u, v, weight in edges:

        if dsu.union(u, v):

            minimum_spanning_tree.append((u, v, weight))

​

    return minimum_spanning_tree

​

# Sample usage of Kruskal's algorithm

edges = [

    (0, 1, 4),

    (0, 2, 3),

    (1, 2, 2),

    (2, 3, 1),

]

n = 4

​

minimum_spanning_tree = kruskal(edges, n)

for edge in minimum_spanning_tree:

    print(edge)