graph

Author: Prakash-sa

Graph/0-1 BFS/Edge Reverse.py

@@ -0,0 +1,85 @@
+# https://maang.in/problems/Edge-Reverse-900?resourceUrl=cs214-cp873-pl3343-rs900&returnUrl=%5B%22%2Fcourses%2FGraph-Level-1-214%3Ftab%3Dchapters%22%5D
+
+'''
+Description
+Given a directed graph with N vertices and M edges. What is the minimum number of edges needed to reverse in order to have at least one path from vertex 1 to vertex N, where the vertices are numbered from 1 to N?
+
+Input Format
+The first line contains T - the number of test cases.
+The first line of each test case contains two space-separated integers N and M, denoting the number of vertices and the number of edges in the graph respectively. The ithith line of the next M lines of each test case contains two space-separated integers Xi and Yi, denoting that the ithith edge connects vertices from Xi to Yi.
+Output Format
+For each test case, in a single line, print the minimum number of edges we need to revert. If there is no way of having at least one path from 1 to N, print −1.
+
+Constraints
+1≤T≤10
+1≤N,M≤105
+1≤Xi,Yi≤N
+There can be multiple edges connecting the same pair of vertices. There can be self-loops too, i.e., Xi=Yi.
+
+Sample Input 1
+1
+7 7
+1 2
+3 2
+3 4
+7 4
+6 2
+5 6
+7 5
+Sample Output 1
+2
+'''
+
+# Write your code here
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+INF = 10**18
+
+
+def solve():
+    t = int(input())
+    ans = []
+
+    for _ in range(t):
+        n, m = map(int, input().split())
+
+        adj = [[] for _ in range(n + 1)]
+
+        for _ in range(m):
+            u, v = map(int, input().split())
+
+            adj[u].append((v, 0))  # original edge
+            adj[v].append((u, 1))  # reversed edge
+
+        dist = [INF] * (n + 1)
+        dist[1] = 0
+
+        dq = deque([1])
+
+        while dq:
+            node = dq.popleft()
+
+            for nei, cost in adj[node]:
+                if dist[node] + cost < dist[nei]:
+                    dist[nei] = dist[node] + cost
+
+                    if cost == 0:
+                        dq.appendleft(nei)
+                    else:
+                        dq.append(nei)
+
+        ans.append(str(dist[n] if dist[n] != INF else -1))
+
+    sys.stdout.write("\n".join(ans))
+
+
+if __name__ == "__main__":
+    solve()
+
+'''
+Time Complexity per test case: O(N+M).
+
+Space Complexity per test case: O(N+M).
+'''

Graph/0-1 BFS/One Piece.py

@@ -0,0 +1,103 @@
+# https://maang.in/problems/One-Piece-902?resourceUrl=cs214-cp873-pl3343-rs902&returnUrl=%5B%22%2Fcourses%2FGraph-Level-1-214%3Ftab%3Dchapters%22%5D
+
+'''
+Description
+Monkey D. Luffy, on his journey of becoming the "King of Pirates" and to conquer the "One Piece", wants to travel across the Grand Line. Grand Line is a mysterious sea, and is in the shape of a N×M grid S with every cell denoting the wind direction. The sign of 
+S[i][j] can be: 1 which means wind in the cell flows to the right (i.e. from 
+S[i][j] to 
+S[i][j+1]), 2 which means wind in the cell flows to the left (i.e. from 
+S[i][j] to 
+S[i][j−1]), 
+3 which means wind in the cell flows downwards (i.e. from 
+S[i][j] to 
+S[i+1][j]), or 
+4 which means wind in the cell flows upwards (i.e. from 
+S[i][j] to 
+S[i−1][j]). Notice that there could be some signs on the cells of the grid 
+S that point outside the Grand Line sea grid.
+
+Merry, Luffy's ship, can only sail along the wind direction and cannot go outside the Grand Line sea grid 
+S at any point. Luffy can modify the wind's direction on a cell with a 
+cost=1 (he can modify the sign on a cell one time only).
+
+Find the minimum cost to make Luffy's voyage from the top-left corner of the Grand Line, i.e., 
+S[1][1], to its bottom-right corner, i.e., 
+S[N][M], possible.
+
+Input Format
+Input is given from Standard Input in the following format:
+S 1,1 S 1,2
+​ …S 
+1,M
+ 
+Output Format
+Print the minimum total cost required to make a path from 
+S[1][1] to 
+S[N][M].
+
+Constraints
+2≤N,M≤1000.
+N and M are integers.
+
+Sample Input 1
+4 4
+1 1 1 1
+2 2 2 2
+1 1 1 1
+2 2 2 2
+Sample Output 1
+3
+Sample Input 2
+3 3
+1 1 3
+3 2 2
+1 1 4
+Sample Output 2
+0
+'''
+# Write your code here
+import sys
+from collections import deque
+
+input=sys.stdin.readline
+
+INF=10**18
+
+dirs=[
+    (0,1),
+    (0,-1),
+    (1,0),
+    (-1,0)
+]
+
+def solve():
+    n,m=list(map(int,input().split()))
+    grid=[]
+    for _ in range(n):
+        grid.append(list(map(int,input().split())))
+    
+    dist=[[INF]*m for _ in range(n)]
+    dist[0][0]=0
+    
+    q=deque([(0,0)])
+    while q:
+        x,y=q.popleft()
+        for k in range(4):
+            nx,ny=x+dirs[k][0],y+dirs[k][1]
+            if 0<=nx<n and 0<=ny<m:
+                cost=0 if grid[x][y]==k+1 else 1
+                if dist[x][y]+cost<dist[nx][ny]:
+                    dist[nx][ny]=cost+dist[x][y]
+                    if cost==0:
+                        q.appendleft((nx,ny))
+                    else:
+                        q.append((nx,ny))
+    print(dist[n-1][m-1])
+
+if __name__=="__main__":
+    solve()
+
+
+# Time Complexity per test case: O(N×M) because each cell is processed at most a constant number of times and there are 4 edges per cell.
+
+# Space Complexity per test case: O(N×M) for the distance matrix and the deque.