lab 5 done

Author: ApurbaKumarNath

3_Algorithms/Lab work/Lab 5/A.py

@@ -0,0 +1,32 @@
+from collections import deque
+
+n, m = map(int, input().split())
+adj_list = [[] for _ in range(n + 1)] # 1-indexed adjacency list
+
+for _ in range(m): # Read m edges (u, v each) and build the adj. list
+    u, v = map(int, input().split())
+    adj_list[u].append(v)
+    adj_list[v].append(u)
+
+traversal_order = []
+start_node = 1
+
+color = [0] * (n + 1) # All vertices are initially white; 0: unvisited/white, 1: visited/Gray; 1-indexed
+color[start_node] = 1 # Mark the start node as Gray
+
+
+queue = deque() 
+queue.append(start_node) # initially add the start node to the queue
+
+
+while queue:
+    u = queue.popleft() # Dequeue the first element
+    traversal_order.append(u) # Append the first element to the traversal order
+
+    for v in adj_list[u]: # For each neighbor of u
+        if color[v] == 0:
+            color[v] = 1
+            queue.append(v)
+            # Mark the neighbor as Gray and add it to the queue
+
+print(" ".join(map(str, traversal_order))) # Print the traversal order

3_Algorithms/Lab work/Lab 5/B.py

@@ -0,0 +1,31 @@
+import sys
+sys.setrecursionlimit(2*10**5 + 10)
+
+def dfs(u, adj, color, traversal_order):
+    color[u] = 1 # Marked visited/Gray
+    traversal_order.append(u) # Append the first element to the traversal order
+
+    for v in adj[u]: # For each neighbor of u
+        if color[v] == 0:
+            dfs(v, adj, color, traversal_order)
+
+n, m = map(int, input().split())
+u_nodes = list(map(int, input().split()))
+v_nodes = list(map(int, input().split()))
+
+adj = [[] for _ in range(n + 1)] # 1-indexed adjacency list as 1st vertex is 1
+
+for i in range(m): # Read m edges (u, v each) and build the adj. list
+    u = u_nodes[i]
+    v = v_nodes[i]
+    adj[u].append(v)
+    adj[v].append(u)
+
+start_node = 1
+traversal_order = []
+
+color = [0] * (n + 1) # All vertices are initially white; 0: unvisited/white, 1: visited/Gray; 1-indexed
+if color[start_node] == 0:
+    dfs(start_node, adj, color, traversal_order)
+print(" ".join(map(str, traversal_order))) # Print the traversal order
+

3_Algorithms/Lab work/Lab 5/C.py

@@ -0,0 +1,73 @@
+from collections import deque
+def solve():
+    n, m, s, dn = map(int, input().split()) # n = no. of vertices, m = no. of edges, s = start node, dn = destination node
+
+    if s == dn:
+        print(0); print(s) # edge case
+        if m > 0:
+            u_nodes = input()
+            v_nodes = input()
+        return
+
+    u_nodes = list(map(int, input().split())) if m > 0 else []
+    v_nodes = list(map(int, input().split())) if m > 0 else []
+
+    #adj list_____________________________________________________________________________________
+
+    adj = [[] for _ in range(n + 1)] # 1-indexed adjacency list as 1st vertex is 1
+
+    for i in range(m): # Read m edges (u, v each) and build the adj. list
+        u = u_nodes[i]; v = v_nodes[i]
+        adj[u].append(v); adj[v].append(u)
+
+    for i in range(1, n + 1):
+        adj[i].sort() # Sort the adjacency list for consistent traversal order
+
+    #initialize BFS_____________________________________________________________________________________
+
+    color = [0] * (n + 1) # All vertices are initially white; 0: unvisited/white, 1: visited/Gray; 1-indexed
+    color[s] = 1 # Mark the start node as Gray
+
+    parent = [-1] * (n + 1) # To store the parent of each node
+
+    d = [-1] * (n + 1) # To store the distance from the start node
+    d[s] = 0 # Distance from start node to itself is 0
+
+    found = False # Flag to check if the destination node is found
+
+    queue = deque() # Initialize the queue
+    queue.append(s) # initially add the start node to the queue
+
+    #BFS loop_____________________________________________________________________________________
+
+    while queue:
+        u = queue.popleft() 
+
+        if u == dn: # If the destination node is found
+            found = True
+            break
+
+        for v in adj[u]: 
+            if color[v] == 0: # if color is white (unvisited)
+                color[v] = 1  # Mark the neighbor as Gray
+                parent[v] = u
+                d[v] = d[u] + 1
+                queue.append(v)
+
+    #output_____________________________________________________________________________________
+
+    if not found:
+        print(-1)
+    else:
+        print(d[dn]) # Print the distance from start node to destination node
+
+        path = []
+        curr = dn
+        while curr != -1:
+            path.append(curr)
+            curr = parent[curr]
+        
+        path.reverse() # Reverse the path to get the correct order
+        print(" ".join(map(str, path))) # Print the path from start node to destination node
+
+solve()

3_Algorithms/Lab work/Lab 5/D.py

@@ -0,0 +1,76 @@
+from collections import deque
+def solve():
+    N, M, S, D, K = map(int, input().split()) # N = no. of vertices, M = no. of edges, S = start node, D = destination node, K = one node between S and D
+
+    #adj list_____________________________________________________________________________________
+
+    adj = [[] for _ in range(N + 1)] # 1-indexed adj. list (1st vertex = 1); directed graph
+    for _ in range(M):
+        u, v = map(int, input().split())
+        adj[u].append(v)
+
+    #output_____________________________________________________________________________________
+
+    dsk, psk = bfs(S, K, adj, N)
+    if dsk == -1:
+        print(-1)
+        return
+    dkd, pkd = bfs(K, D, adj, N) 
+    if dkd == -1:
+        print(-1)
+        return
+    
+    print(dsk + dkd)
+    print(' '.join(map(str, psk + pkd[1:]))) # print the path from S to K and from K to D, excluding K in the second part of the path
+
+#initialize BFS_____________________________________________________________________________________
+
+def bfs(S, D, adj, N):
+    if S == D:
+        return 0, [S] # edge case
+    
+    color = [0] * (N + 1)
+    color[S] = 1
+
+    parent = [-1] * (N + 1)
+
+    d = [-1] * (N + 1)
+    d[S] = 0
+
+    found = False
+
+    queue = deque()
+    queue.append(S)
+
+    #BFS loop_____________________________________________________________________________________
+
+    while queue:
+        u = queue.popleft() 
+
+        for v in adj[u]: 
+            if color[v] == 0:
+                color[v] = 1
+                parent[v] = u
+                d[v] = d[u] + 1
+                queue.append(v)
+
+                if v == D:
+                    found = True
+                    break
+
+    if not found:
+        return -1, -1
+    
+    #path reconstruction_____________________________________________________________________________________
+
+    path = []
+    curr = D
+    
+    while curr != -1:
+        path.append(curr)
+        curr = parent[curr]
+    path.reverse()
+
+    return d[D], path # returns the distance from S to D and the path from S to D
+
+solve()

3_Algorithms/Lab work/Lab 5/E.py

@@ -0,0 +1,35 @@
+import sys
+sys.setrecursionlimit(2*10**5 + 10)
+
+def dfs_cycle(u, adj, color):
+    color[u] = 1
+
+    for v in adj[u]:
+        if color[v] == 1: # Gray to Gray (Back edge); cycle detected
+            return True
+        if color[v] == 0:
+            if dfs_cycle(v, adj, color): # Recursive call to check for cycles
+                return True
+    
+    color[u] = 2 # Mark as Black (visited); no adj. vertices left to explore
+    return False # No cycle detected
+
+N, M = map(int, input().split())
+
+adj = [[] for _ in range(N + 1)] # 1-indexed adjacency list
+for _ in range(M):
+    u, v = map(int, input().split())
+    adj[u].append(v) # directed graph
+
+color = [0] * (N + 1) # 0: unvisited/white, 1: visited/Gray, 2: visited/Black
+has_cycle = False
+
+for u in range(1, N + 1):
+    if color[u] == 0: # If the vertex is unvisited
+        if dfs_cycle(u, adj, color): # Check for cycles
+            has_cycle = True
+            print("YES")
+            break
+
+if not has_cycle:
+    print("NO") # No cycles detected

3_Algorithms/Lab work/Lab 5/F.py

@@ -0,0 +1,46 @@
+from collections import deque
+
+R, H = map(int, input().split()) # R= rows, H=columns
+grid = [input().strip() for _ in range(R)] # Read grid row by row
+
+color = [[0 for _ in range(H)] for _ in range(R)] # 0: unvisited/white, 1: visited/Gray
+max_diamonds = 0
+
+dr = [-1, 1, 0, 0] # row direction
+dc = [0, 0, -1, 1] # column direction
+# i for dr and dc; 0: up, 1: down, 2: left, 3: right
+
+#BFS initialization with outer loop for unconnected components__________________________________
+
+for r in range(R):
+    for c in range(H):
+        if grid[r][c] != '#' and color[r][c] == 0: # if unvisited and not a wall
+            color[r][c] = 1
+
+            curr_diamonds = 0
+            if grid[r][c] == 'D':
+                curr_diamonds += 1
+
+            queue = deque() # Start BFS
+            queue.append((r, c)) # Enqueue the starting cell
+
+            #BFS loop_____________________________________________________________________________________
+
+            while queue:
+                ur, uc = queue.popleft() # Dequeue the first element
+
+                for i in range(4): # Check all 4 directions (up, down, left, right); checking adjacents of u (ur, uc)
+                    vr = ur + dr[i]
+                    vc = uc + dc[i]
+
+                    if 0 <= vr < R and 0 <= vc < H: # Check if within bounds
+                        if grid[vr][vc] != '#' and color[vr][vc] == 0: # if unvisited and not a wall
+
+                            color[vr][vc] = 1
+                            if grid[vr][vc] == 'D':
+                                curr_diamonds += 1
+                            queue.append((vr, vc))
+
+            # Update the maximum number of diamonds found in this component________________________________
+            max_diamonds = max(max_diamonds, curr_diamonds)
+print(max_diamonds)