Week 5 - MST and Toposort

Author: kalpak92

week2_decomposition2/.DS_Store

@@ -2,8 +2,34 @@
 
 import sys
 
+visited  = []
+recStack = []
+
+def isCyclicUtil(adj, v):
+    global visited
+    global recStack
+    if not visited[v]:
+        visited[v] = True
+        recStack[v] = True
+        for w in adj[v]:
+            if (not visited[w]) and isCyclicUtil(adj, w):
+                return True
+            elif recStack[w]:
+                return True
+    recStack[v] = False
+    return False
 
 def acyclic(adj):
+    global visited
+    global recStack
+
+    visited = [False] * len(adj)
+    recStack = [False] * len(adj)
+    
+    for v in range(len(adj)):
+        if isCyclicUtil(adj, v):
+            return 1 #True
+    
     return 0
 
 if __name__ == '__main__':

week2_decomposition2/1_acyclicity/acyclicity.py

@@ -2,15 +2,25 @@
 
 import sys
 
-def dfs(adj, used, order, x):
-    #write your code here
-    pass
+visited = []
+order = []
 
+def explore(adj, v):
+    global visited
+    global order
+    visited[v] = True
+    for w in adj[v]:
+        if not visited[w]:
+            explore(adj, w)
+    order.insert(0, v)
 
 def toposort(adj):
-    used = [0] * len(adj)
-    order = []
-    #write your code here
+    global visited
+    global order
+    visited = [False] * len(adj)
+    for v in range(len(adj)):
+        if not visited[v]:
+            explore(adj, v)
     return order
 
 if __name__ == '__main__':

week2_decomposition2/2_toposort/toposort.py

@@ -5,9 +5,52 @@
 sys.setrecursionlimit(200000)
 
 
+visited = []
+order = []
+
+def reverseGraph(adj):
+    n = len(adj)
+    adjr = [[] for _ in range(n)]
+    for v in range(len(adj)):
+        for w in adj[v]:
+            adjr[w].append(v)
+    return adjr
+
+def explore(adj, v):
+    global visited
+    visited[v] = True
+    for w in adj[v]:
+        if not visited[w]:
+            explore(adj, w)
+
+def exploreForOrder(adj, v):
+    global visited
+    global order
+    visited[v] = True
+    for w in adj[v]:
+        if not visited[w]:
+            exploreForOrder(adj, w)
+    order.insert(0, v)
+
+def toposort(adj):
+    global visited
+    global order
+    visited = [False] * len(adj)
+    for v in range(len(adj)):
+        if not visited[v]:
+            exploreForOrder(adj, v)
+    return order
+
 def number_of_strongly_connected_components(adj):
+    global visited
     result = 0
-    #write your code here
+    adjr = reverseGraph(adj)
+    order = toposort(adjr)
+    visited = [False] * len(adj)
+    for v in order:
+        if not visited[v]:
+            explore(adj, v)
+            result += 1
     return result
 
 if __name__ == '__main__':

week2_decomposition2/3_strongly_connected/strongly_connected.py

@@ -1,10 +1,39 @@
 #Uses python3
 import sys
 import math
+import queue
+
+def distance(x1, y1, x2, y2):
+    return ((x1-x2)**2+(y1-y2)**2)**0.5
 
 def minimum_distance(x, y):
     result = 0.
     #write your code here
+    n = len(x)
+
+    cost = [float('inf')] * n
+    cost[0] = 0
+
+    Q = queue.PriorityQueue()
+    Q.put((0, 0))
+
+    processed = set()
+
+    while not Q.empty():
+        d, v = Q.get()
+
+        if v not in processed:
+            result += d
+            processed.add(v)
+
+            for z in range(n):
+                if z not in processed:
+                    currCost = distance(x[v], y[v], x[z], y[z])
+
+                    if cost[z] > currCost:
+                        cost[z] = currCost
+                        Q.put((currCost, z))
+
     return result
 
 

week2_decomposition2/Graph_decomposition_6_DAGs.pdf

@@ -1,9 +1,53 @@
 #Uses python3
 import sys
 import math
+import queue
+
+def distance(x1, y1, x2, y2):
+    return ((x1-x2)**2+(y1-y2)**2)**0.5
+
+class DisjointSet:
+    def __init__(self, n):
+        self.parent = list(range(n))
+        self.rank = [0] * n
+        self.regions = n
+    
+    def find(self, i):
+        while i != self.parent[i]:
+            i = self.parent[i]
+        return i
+    
+    def union(self, i, j):
+        i_id = self.find(i)
+        j_id = self.find(j)
+        if i_id == j_id:
+            return
+        self.regions -= 1
+        if self.rank[i_id] > self.rank[j_id]:
+            self.parent[j_id] = i_id
+        else:
+            self.parent[i_id] = j_id
+            if self.rank[i_id] == self.rank[j_id]:
+                self.rank[j_id] += 1
+
 
 def clustering(x, y, k):
     #write your code here
+
+    n = len(x)
+    D = DisjointSet(n)
+    Q = queue.PriorityQueue()
+    for i in range(n):
+        for j in range(i+1, n):
+            Q.put((distance(x[i], y[i], x[j], y[j]), (i, j)))
+
+    while not Q.empty():
+        dist, (u, v) = Q.get()
+        if D.find(u) != D.find(v):
+            if D.regions == k:
+                return dist
+            D.union(u, v)
+
     return -1.