Added Algorithms and DS

Author: jai2dev

Diff for: Dasgupta-Papadimitriou-Vazirani.pdf

@@ -0,0 +1,63 @@
+from collections import defaultdict
+class Graph:
+	"""docstring for Graph"""
+	def __init__(self):
+		# super(Graph, self).__init__()
+		# self.arg = arg
+		self.graph= defaultdict(list)
+
+
+	def addEdge(self,u,v):
+		self.graph[u].append(v)
+
+	def BFS(self,s):
+		queue=[]
+		visited=[False]*(len(self.graph))
+		queue.append(s)
+		visited[s]=True
+		bfs=[]
+		while queue:
+			v=queue.pop(0)
+			bfs.append(v)
+			for i in self.graph[v]:
+				if visited[i]==False:
+					queue.append(i)
+					visited[i]=True
+
+		return bfs
+
+
+	def bfsTree(self,root):
+		queue=deque()
+		queue.append(root)
+		ans=[]
+		while queue:
+			curSize=len(queue)
+			temp=[]
+			for _ in range(curSize):
+				curRoot=queue.popleft()
+				temp.append(curRoot.val)
+				if curRoot.left:
+					queue.append(curRoot.left)
+				if curRoot.right:
+					queue.append(curRoot.right)
+			ans.append(temp)
+		return ans
+
+
+
+
+
+if __name__ == '__main__':
+	g=Graph()
+
+	g.addEdge(0,1)
+	g.addEdge(0,2)
+	g.addEdge(1,2)
+	g.addEdge(2,0)
+	g.addEdge(2,3)
+	g.addEdge(3,3)
+
+	print(g.BFS(2))
+
+

Diff for: Introduction-to-Algorithms-CLRS-3rd-Edition.pdf

@@ -0,0 +1,85 @@
+from threading import *
+import time
+
+class Node:
+	def __init__(self,val):
+		self.val=val
+		self.next=None
+		self.prev=None
+
+class BoundedBlockingQueue:
+	def __init__(self,capacity):
+		self.capacity=capacity
+		self.queue_lock=Lock()
+		self.enqueue_condition=Condition(self.queue_lock)
+		self.dequeue_condition=Condition(self.queue_lock)
+		self.size=0
+		self.head=Node(-1)
+		self.tail=Node(-2)
+		self.head.next=self.tail
+		self.tail.prev=self.head
+
+
+	def enqueue(self,v):
+		with self.queue_lock:
+			while self.size==self.capacity:
+				self.enqueue_condition.wait()
+			nex=self.tail
+			prev=self.tail.prev
+			cur=Node(v)
+			cur.next=nex
+			nex.prev=cur
+			prev.next=cur
+			cur.prev=prev
+			self.size+=1
+			self.dequeue_condition.notify()
+
+
+
+
+	def deque(self):
+		with self.queue_lock:
+			while self.size==0:
+				self.dequeue_condition.wait()
+			prev=self.head
+			cur=self.head.next
+			nex=cur.next
+			prev.next=nex
+			nex.prev=prev
+			v=cur.val
+			cur.prev=None
+			cur.next=None
+			self.size-=1
+			self.enqueue_condition.notify()
+		return v
+
+	def get_size(self):
+		with self.queue_lock:
+			return self.size
+
+if __name__ == "__main__":
+    def producer(queue, items):
+        for item in items:
+            print(f"Producing {item}")
+            queue.enqueue(item)
+            time.sleep(0.1)  # Simulate production time
+
+    def consumer(queue, n):
+        for _ in range(n):
+            item = queue.deque()
+            print(f"Consumed {item}")
+            time.sleep(0.2)  # Simulate consumption time
+
+    queue = BoundedBlockingQueue(5)
+    items = range(10)
+    
+    producer_thread = Thread(target=producer, args=(queue, items))
+    consumer_thread = Thread(target=consumer, args=(queue, len(items)))
+
+    producer_thread.start()
+    consumer_thread.start()
+
+    producer_thread.join()
+    consumer_thread.join()
+
+

Diff for: bfs.py

@@ -0,0 +1,43 @@
+from collections import defaultdict as dt
+import sys
+sys.setrecursionlimit(10**9)
+
+
+class Graph:
+	def __init__(self,nodes):
+		self.graph=dt(lambda:[])
+		self.nodes=nodes
+		self.bridges=[]
+
+
+	def add_edge(self,u,v):
+		self.graph[u].append(v)
+		self.graph[v].append(u)
+
+	def dfs(self,u,lowest_reachable_node,time_of_insertion,visited,time,par):
+		time_of_insertion=lowest_reachable_node=time+1
+		visited[u]=1
+
+		for v in self.graph[u]:
+			if not visited[v]:
+				self.dfs(v,lowest_reachable_node,time_of_insertion,visited,time+1,u)
+				lowest_reachable_node[u]=min(lowest_reachable_node[u],lowest_reachable_node[v])
+
+				if lowest_reachable_node[v]>time_of_insertion[u]:
+					self.bridges.append((u,v))
+
+			elif visited[v] and v!=par:
+				lowest_reachable_node[u]=min(lowest_reachable_node[u],lowest_reachable_node[v])
+
+		
+
+
+
+if __name__ == '__main__':
+	graph=Graph(15)
+
+	for i,j in zip(range(10),range(15,5,-1)):
+		g.add_edge(i,j)
+
+	g.dfs(0,[0]*15,[0]*15,[0]*15,0,-1)
+

Diff for: boundedblockingqueue.py

@@ -0,0 +1,48 @@
+from collections import defaultdict
+
+class Graph:
+	"""docstring for Graph"""
+	def __init__(self, ver):
+		# super(Graph, self).__init__()
+		self.ver = ver
+		self.graph=defaultdict(list)
+
+	def addEdge(self,u,v):
+		self.graph[u].append(v)
+		self.graph[v].append(u)
+
+	def util(self,v,visited,compo):
+		visited[v]=True
+
+		compo.append(v)
+
+		for i in self.graph[v]:
+			if visited[i]==False:
+				compo=self.util(i,visited,compo)
+		return compo
+
+	def conncompo(self):
+		visited=[False]*self.ver
+
+		cc=[]
+
+		for i in range(self.ver):
+			if visited[i]==False:
+				compo=[]
+				cc.append(self.util(i,visited,compo))
+		return cc
+
+if __name__=="__main__": 
+      
+    # Create a graph given in the above diagram 
+    # 5 vertices numbered from 0 to 4 
+    g = Graph(5); 
+    g.addEdge(1, 0) 
+    g.addEdge(2, 3) 
+    g.addEdge(3, 4) 
+    cc = g.conncompo() 
+    print("Following are connected components") 
+    print(cc) 
+
+
+

Diff for: bridges.py

@@ -0,0 +1,77 @@
+import sys,traceback,hashlib,bisect,re
+from sortedcontainers import SortedList
+
+class Node:
+	def __init__(self,nodeId,name,weight):
+		self.id=nodeId
+		self.name=name
+		self.weight=weight #relative load that this node can handle, the more the weight more the number of virtual nodes on the hash ring
+
+
+class ConsistentHashing:
+	def __init__(self):
+		self.nodes=SortedList()
+		self.nodeIdToNodes={}
+		self.nodeToId=defaultdict(lambda:[])
+
+	def hash(self,request, limit=4294967295):
+        keyHash=hashlib,sha512(request.encode())
+        key=int.from_bytes(keyHash.digest(),"big")%limit
+        return key
+
+    def deleteNode(self,node):
+    	'''
+    	Function that could be used to remove the node from the cluster
+    	'''
+    	return True
+
+    def addNode(self,node):
+      	'''
+    	Function that could be used to add the node from the cluster
+    	'''
+    	return True
+
+	def getNode(self,request):
+		requestId=self.hash(request)
+		nodeIdIndex=self.nodes.bisect_left(requestId)
+		if nodeIdIndex<len(self.nodes):
+			return self.nodeIdToNodes[self.nodes[nodeIdIndex]]
+		return self.nodeIdToNodes[self.nodes[0]]
+
+	def addNode(self,node):
+		nodeId=node.id
+		for i in range(1,node.weight+1):
+			virtualNodeId=self.hash(nodeId+i)
+			self.nodeIdToNodes[virtualNodeId]=node
+			self.node.add(virtualNodeId)
+			self.nodeToId[node].append(virtualNodeId)
+		self.addNode(node)
+		return "Successfully Added Node"
+
+	def removeNode(self,node):
+		for  nodeId in self.nodeToId[node]:
+			del self.nodeIdToNodes[nodeId]
+			self.nodes.remove(nodeId)
+		del self.nodeToId[node]
+		self.deleteNode(node)
+		return "Successfully removed the Node"
+
+
+
+
+class LoadBalancer:
+	def __init__(self):
+		self.algorithm=ConsistentHashing()
+
+
+	def addNode(self,node):
+		self.algorithm.addNode(node)
+
+	def removeNode(self,node):
+		self.algorithm.removeNode(node)
+
+	def getNode(self,request):
+		return self.algorithm(request)
+
+
+

Diff for: cc.py

@@ -0,0 +1,60 @@
+from collections import defaultdict
+
+class Graph:
+	"""docstring for Graph"""
+	def __init__(self, ver):
+		# super(Graph, self).__init__()
+		self.ver = ver
+		self.graph=defaultdict(list)
+
+
+	def addEdge(self,u,v):
+		self.graph[u].append(v)
+
+	def cycleutil(self,v,visited,rec):
+		
+		visited[v]=True
+		rec[v]=True
+
+		for i in self.graph[v]:
+			if visited[i]==False:
+				if self.cycleutil(i,visited,rec):
+					return True
+
+			elif rec[i]==True:
+				return True
+
+		rec[v]=False
+
+		return False
+
+	def cycle(self):
+		
+		visited=[False]*self.ver
+
+		rec=[False]*self.ver
+
+		for i in range(self.ver):
+
+			if visited[i]==False:
+				if self.cycleutil(i,visited,rec)==True:
+				    return True
+
+		return False
+
+
+
+
+g = Graph(4) 
+g.addEdge(0, 1) 
+g.addEdge(0, 2) 
+g.addEdge(1, 2) 
+g.addEdge(2, 0) 
+g.addEdge(2, 3) 
+g.addEdge(3, 3) 
+if g.cycle(): 
+    print ("Graph has a cycle")
+else: 
+    print( "Graph has no cycle")
+
+