Graph

Author: Prakash-sa

Graph/BFS/Bidirectional BFS.py

@@ -0,0 +1,181 @@
+# https://maang.in/problems/Connected-Component-Size-684?resourceUrl=cs214-cp873-pl3338-rs684&returnUrl=%5B%22%2Fcourses%2FGraph-Level-1-214%3Ftab%3Dchapters%22%5D
+
+"""
+Description
+You have a 2-D array of size N×M. Consider connected 0's (which share a common edge) as one single component and 1's as walls. Replace 0's with the size of the connected component but if the size of the component is one, then leave it with 0.
+
+Input Format
+The first line contains a single integer t, the number of test cases. For each test case, the first line contains two integers
+N and M and then there are N lines containing N×M binary matrix.
+
+Output Format
+For each test case, print the final matrix after replacing all the 0's accordingly.
+
+Constraints
+(N×M) over all test cases ≤2×105
+
+0≤Ai≤1
+
+Sample Input 1
+2
+2 2
+0 1
+1 0
+6 5
+1 0 0 1 0
+0 1 0 0 0
+0 0 1 1 0
+0 1 1 0 1
+1 1 1 1 1
+0 1 0 0 0
+Sample Output 1
+0 1
+1 0
+1 7 7 1 7
+4 1 7 7 7
+4 4 1 1 7
+4 1 1 0 1
+1 1 1 1 1
+0 1 3 3 3
+"""
+
+
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+print = sys.stdout.write
+
+direction = [(1, 0), (0, 1), (-1, 0), (0, -1)]
+
+
+def list_ints():
+    return list(map(int, input().split()))
+
+
+def bfs(x, y, grid):
+    vis = set()
+    vis.add((x, y))
+
+    q = deque([(x, y)])
+    size = 0
+
+    while q:
+        x, y = q.popleft()
+        size += 1
+
+        for dx, dy in direction:
+            nx, ny = x + dx, y + dy
+
+            if 0 <= nx < len(grid) and 0 <= ny < len(grid[0]):
+                if (nx, ny) in vis or grid[nx][ny] == "1":
+                    continue
+
+                vis.add((nx, ny))
+                q.append((nx, ny))
+
+    return size
+
+
+def solve():
+    t = int(input())
+
+    for _ in range(t):
+        n, m = list_ints()
+
+        grid = []
+        for _ in range(n):
+            grid.append(input().strip().split())
+
+        ans = []
+
+        for i in range(n):
+            row = []
+            for j in range(m):
+                if grid[i][j] == "1":
+                    row.append("1")
+                else:
+                    size = bfs(i, j, grid)
+                    row.append("0" if size == 1 else str(size))
+
+            ans.append(" ".join(row))
+
+        print("\n".join(ans) + "\n")
+
+
+if __name__ == "__main__":
+    solve()
+
+    import sys
+from collections import deque
+
+input = sys.stdin.readline
+print = sys.stdout.write
+
+direction = [(1, 0), (0, 1), (-1, 0), (0, -1)]
+
+
+def list_ints():
+    return list(map(int, input().split()))
+
+
+def solve():
+    t = int(input())
+
+    for _ in range(t):
+        n, m = list_ints()
+
+        # for "0 1 0" input
+        grid = [input().strip().split() for _ in range(n)]
+        # if input is "010", use:
+        # grid = [list(input().strip()) for _ in range(n)]
+
+        comp_id = [[-1] * m for _ in range(n)]
+        comp_size = []
+        cid = 0
+
+        # BFS to find components of '0'
+        for i in range(n):
+            for j in range(m):
+                if grid[i][j] == "0" and comp_id[i][j] == -1:
+                    q = deque([(i, j)])
+                    comp_id[i][j] = cid
+                    size = 1
+
+                    while q:
+                        x, y = q.popleft()
+
+                        for dx, dy in direction:
+                            nx, ny = x + dx, y + dy
+
+                            if 0 <= nx < n and 0 <= ny < m:
+                                if grid[nx][ny] == "0" and comp_id[nx][ny] == -1:
+                                    comp_id[nx][ny] = cid
+                                    q.append((nx, ny))
+                                    size += 1
+
+                    comp_size.append(size)
+                    cid += 1
+
+        # Build answer
+        ans = []
+        for i in range(n):
+            row = []
+            for j in range(m):
+                if grid[i][j] == "1":
+                    row.append("1")
+                else:
+                    size = comp_size[comp_id[i][j]]
+                    row.append("0" if size == 1 else str(size))
+            ans.append(" ".join(row))
+
+        print("\n".join(ans) + "\n")
+
+
+if __name__ == "__main__":
+    solve()
+
+
+"""
+Time Complexity per test case: O(N×M). Space Complexity per test case: O(N×M).
+"""

Graph/BFS/Connected Component Size.py

@@ -0,0 +1,99 @@
+# https://maang.in/problems/Creating-Teams-193?resourceUrl=cs214-cp873-pl3339-rs193&returnUrl=%5B%22%2Fcourses%2FGraph-Level-1-214%3Ftab%3Dchapters%22%5D
+
+
+"""
+Description
+There are n students in the AlgoZenith course and m friendships between them. Your task is to divide the students into two teams in such a way that no two students in a team are friends. You can freely choose the sizes of the teams. The size of each team should be positive.
+
+Input Format
+The first input line has two integers n and m: the number of students and friendships. The students are numbered
+1,2,…,n.
+Then, there are m lines describing friendships. Each line has two integers a and b: students a and b are friends.
+Every friendship is between two different students. You can assume that there is at most one friendship between any two students.
+
+Output Format
+Print YES if it's possible to divide students in two teams, otherwise print NO.
+
+Constraints
+1≤n≤105
+0≤m≤2×105
+1≤a,b≤n
+
+Sample Input 1
+5 3
+1 2
+1 3
+4 5
+Sample Output 1
+YES
+Sample Input 2
+4 3
+1 2
+2 3
+1 3
+Sample Output 2
+NO
+"""
+
+import sys
+from sys import stdin, stdout
+
+sys.setrecursionlimit(10**7)
+
+
+def dfs(v, c, color, adj):
+    color[v] = c
+    for u in adj[v]:
+        if color[u] == -1:
+            if not dfs(u, 1 - c, color, adj):
+                return False
+        elif color[u] == color[v]:
+            return False
+    return True
+
+
+def main():
+    data = stdin.read().split()
+    idx = 0
+    n = int(data[idx])
+    idx += 1
+    m = int(data[idx])
+    idx += 1
+    adj = [[] for _ in range(n + 1)]
+    for _ in range(m):
+        u = int(data[idx])
+        v = int(data[idx + 1])
+        idx += 2
+        adj[u].append(v)
+        adj[v].append(u)
+    color = [-1] * (n + 1)
+    for v in range(1, n + 1):
+        if color[v] == -1:
+            if not dfs(v, 0, color, adj):
+                stdout.write("NO\n")
+                return
+    stdout.write("YES\n")
+
+
+if __name__ == "__main__":
+    main()
+
+
+"""
+⏱️ Time Complexity
+O(N + M)
+
+Where:
+
+N = number of nodes
+M = number of edges
+Why?
+Each node is visited once
+Each edge is checked twice (undirected)
+💾 Space Complexity
+O(N + M)
+Breakdown:
+adj list → O(N + M)
+color array → O(N)
+recursion stack (DFS) / queue (BFS) → O(N) worst case
+"""

Graph/Bipartite/Creating Teams.py

@@ -0,0 +1,78 @@
+"""
+Description
+You have been given a tree with N nodes and N−1 edges. You want to colour each node, such that no two adjacent nodes (directly connected by an edge) and no two nearly-adjacent nodes (both directly connected to a common node with edges) has the same colour. Your task is to find the minimum number of colours required to accomplished this.
+
+Input Format
+The first line of input contains N. Each of the remaining N−1 lines describes an edge in terms of the two nodes it connects.
+
+Output Format
+Print the minimum number of colours required.
+
+Constraints
+1≤N≤10 5
+
+
+Sample Input 1
+4
+1 2
+4 3
+2 3
+Sample Output 1
+3
+
+"""
+
+import sys
+from collections import defaultdict
+
+input = sys.stdin.readline
+print = sys.stdout.write
+sys.setrecursionlimit(1 << 25)
+
+MOD = 10**9 + 7
+INF = 10**18
+
+
+def read():
+    return sys.stdin.buffer.read()
+
+
+def ints():
+    return map(int, input().split())
+
+
+def list_ints():
+    return list(map(int, input().split()))
+
+
+def write_line(value=""):
+    sys.stdout.write(str(value) + "\n")
+
+
+def write_lines(values):
+    sys.stdout.write("\n".join(map(str, values)))
+    if values:
+        sys.stdout.write("\n")
+
+
+direction = [(1, 0), (0, 1), (-1, 0), (0, -1)]
+
+
+def solve():
+    [n] = list_ints()
+    degree = [0] * (n + 1)
+    for _ in range(n - 1):
+        [u, v] = list_ints()
+        degree[u] += 1
+        degree[v] += 1
+
+    write_line(max(degree) + 1)
+
+
+if __name__ == "__main__":
+    solve()
+
+"""
+Time:  O(N)
+Space: O(N)
+"""

Graph/Connected Components/Color_Tree.py

@@ -0,0 +1,34 @@
+# https://maang.in/problems/Creating-Teams-193?resourceUrl=cs214-cp873-pl3339-rs193&returnUrl=%5B%22%2Fcourses%2FGraph-Level-1-214%3Ftab%3Dchapters%22%5D
+
+"""
+Description
+There are n students in the AlgoZenith course and m friendships between them. Your task is to divide the students into two teams in such a way that no two students in a team are friends. You can freely choose the sizes of the teams. The size of each team should be positive.
+
+Input Format
+The first input line has two integers n and m: the number of students and friendships. The students are numbered 1,2,…,n.
+Then, there are m lines describing friendships. Each line has two integers a and b: students a and b are friends.
+Every friendship is between two different students. You can assume that there is at most one friendship between any two students.
+
+Output Format
+Print YES if it's possible to divide students in two teams, otherwise print NO.
+
+Constraints
+1≤n≤105
+0≤m≤2×105
+1≤a,b≤n
+
+Sample Input 1
+5 3
+1 2
+1 3
+4 5
+Sample Output 1
+YES
+Sample Input 2
+4 3
+1 2
+2 3
+1 3
+Sample Output 2
+NO
+"""