Upload 9.py

9.py

@@ -0,0 +1,126 @@
+import heapq 
+import itertools 
+ 
+# ---------------- Priority Queue ---------------- 
+ 
+class AdaptableHeapPriorityQueue: 
+    def __init__(self): 
+        self._heap = [] 
+        self._counter = itertools.count() 
+ 
+    def add(self, key, value): 
+        entry = [key, next(self._counter), value] 
+        heapq.heappush(self._heap, entry) 
+        return entry 
+ 
+    def update(self, entry, newkey, newvalue): 
+        entry[0] = newkey 
+        entry[2] = newvalue 
+        heapq.heapify(self._heap) 
+ 
+    def remove_min(self): 
+        while self._heap: 
+            key, _, value = heapq.heappop(self._heap) 
+            return key, value 
+        raise KeyError("Priority queue is empty") 
+ 
+    def is_empty(self): 
+        return len(self._heap) == 0 
+ 
+# ---------------- Graph Classes ---------------- 
+ 
+class Vertex: 
+    def __init__(self, label): 
+        self.label = label 
+ 
+    def __hash__(self): 
+        return hash(self.label) 
+ 
+    def __str__(self): 
+        return str(self.label) 
+ 
+class Edge: 
+    def __init__(self, u, v, w): 
+        self._u = u 
+        self._v = v 
+        self._w = w 
+ 
+    def opposite(self, x): 
+        return self._v if x == self._u else self._u 
+ 
+    def element(self): 
+        return self._w 
+ 
+    def endpoints(self): 
+        return (self._u, self._v) 
+ 
+class Graph: 
+    def __init__(self): 
+        self._adj = {} 
+ 
+    def add_vertex(self, label): 
+        v = Vertex(label) 
+        self._adj[v] = [] 
+        return v 
+ 
+    def add_edge(self, u, v, w): 
+        e = Edge(u, v, w) 
+        self._adj[u].append(e) 
+        self._adj[v].append(e) 
+ 
+    def vertices(self): 
+        return self._adj.keys() 
+ 
+    def incident_edges(self, v): 
+        return self._adj[v] 
+     
+# ---------------- Prim-Jarník Algorithm ---------------- 
+def MST_PrimJarnik(g): 
+     
+    d = {}                                
+    tree = []                             
+    pq = AdaptableHeapPriorityQueue()     
+ 
+ 
+    pqlocator = {}                        
+    for v in g.vertices(): 
+ 
+        if len(d) == 0:                   
+            d[v] = 0                      
+        else: 
+            d[v] = float('inf')           
+        pqlocator[v] = pq.add(d[v], (v, None)) 
+    while not pq.is_empty(): 
+        key, value = pq.remove_min() 
+        u, edge = value                   
+        del pqlocator[u]                  
+        if edge is not None: 
+            tree.append(edge)           
+        for link in g.incident_edges(u): 
+            v = link.opposite(u) 
+            if v in pqlocator:            
+                wgt = link.element() 
+                if wgt < d[v]:           
+                    d[v] = wgt            
+                    pq.update(pqlocator[v], d[v], (v, link))  
+    return tree 
+print("\Minimum Spanning Tree") 
+print("\t---------------------------------") 
+n = int(input("Enter number of vertices: ")) 
+m = int(input("Enter number of edges: ")) 
+g = Graph() 
+vertices = [] 
+for i in range(n+1): 
+    vertices.append(g.add_vertex(i)) 
+print("Enter vertices of each edges and its weight as: u v weight") 
+for _ in range(m): 
+    u, v, w = map(int, input().split()) 
+    g.add_edge(vertices[u], vertices[v], w) 
+mst = MST_PrimJarnik(g) 
+print("\nEdges in the Minimum Spanning Tree:") 
+total = 0 
+for e in mst: 
+    u, v = e.endpoints() 
+    print(f"{u} -- {v} (weight = {e.element()})") 
+    total += e.element() 
+print("Total weight of MST:", total)