Breaking News: Grepper is joining You.com. Read the official announcement!

kruskal python implementation

Add Answer

Nervous Newt answered on April 29, 2022 Popularity 9/10 Helpfulness 5/10

answer kruskal python implementation

related kruskal python

related kruskal's algorithm python

kruskal python implementation

Comment

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()

Popularity 9/10 Helpfulness 5/10 Language python

Source: www.pythonpool.com

Tags: implementation python

Link to this answer
Share Copy Link

Contributed on Apr 29 2022

Nervous Newt

0 Answers Avg Quality 2/10

Closely Related Answers

kruskal python

Comment

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)

Popularity 7/10 Helpfulness 8/10 Language python

Source: chat.openai.com

Tags: python

Link to this answer
Share Copy Link

Contributed on Oct 23 2023

Innocent Iguana

0 Answers Avg Quality 2/10

kruskal's algorithm python

Comment

# 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)

Popularity 7/10 Helpfulness 1/10 Language python

Source: Grepper

Link to this answer
Share Copy Link

Contributed on Sep 12 2023

YOU.com

0 Answers Avg Quality 2/10

kruskal python implementation

Contents

More Related Answers

kruskal python implementation

Closely Related Answers

kruskal python

kruskal's algorithm python

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.