Initial Commit

Author: dk67604

coding_2025/graphs/find_cycle.py

@@ -1,3 +1,57 @@
 '''
 Directed Graph
-'''
+'''
+
+from collections import defaultdict
+
+WHITE, GRAY, BLACK = 0, 1,2
+
+def has_cycle(graph):
+    color = defaultdict(lambda: WHITE)
+
+    def dfs(node):
+        if color[node] == GRAY:
+            return True
+        if color[node] == BLACK:
+            return False
+
+        color[node] = GRAY
+
+        for neighbor in graph[node]:
+            if dfs(neighbor):
+                return True
+        color[node] = BLACK
+        return False
+
+    for node in graph:
+        if color[node] == WHITE:
+            if dfs(node):
+                return True
+
+    return False
+
+
+
+
+def has_cycle_undirected(graph):
+    visited = set()
+
+    def dfs(node, parent):
+        visited.add(node)
+
+        for neighbor in graph[node]:
+            if neighbor not in visited:
+                if dfs(neighbor, node):
+                    return True
+            elif neighbor != parent:
+                # Back edge found (cycle)
+                return True
+
+        return False
+
+    for node in graph:
+        if node not in visited:
+            if dfs(node, None):
+                return True
+
+    return False

coding_2025/meta/lc_536.py

@@ -57,7 +57,7 @@ def getNumber(index: int) -> (int, int):
                 node.right = TreeNode()             # Prepare right child node
                 stack.append(node.right)            # Add right child to stack
 
-            index += 1  # Move to next character
+            index += 1  # Move to next character This next character could ')'
 
         # At the end, either stack has one last parent to return, or return root
         return stack.pop() if stack else root

coding_2025/meta/lc_54.py

@@ -0,0 +1,35 @@
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+
+        res = []  # This will store the elements in spiral order
+        left, right = 0, len(matrix[0])  # Initialize left and right pointers for columns
+        top, bottom = 0, len(matrix)     # Initialize top and bottom pointers for rows
+
+        # Loop until the pointers cross each other
+        while left < right and top < bottom:
+
+            # Traverse from left to right on the top row
+            for i in range(left, right):
+                res.append(matrix[top][i])
+            top += 1  # Move the top boundary down
+
+            # Traverse from top to bottom on the rightmost column
+            for i in range(top, bottom):
+                res.append(matrix[i][right - 1])
+            right -= 1  # Move the right boundary left
+
+            # Check if we are still within valid boundaries after moving top and right
+            if not (left < right and top < bottom):
+                break  # If the matrix is fully traversed, exit the loop
+
+            # Traverse from right to left on the bottom row
+            for i in range(right - 1, left - 1, -1):
+                res.append(matrix[bottom - 1][i])
+            bottom -= 1  # Move the bottom boundary up
+
+            # Traverse from bottom to top on the leftmost column
+            for i in range(bottom - 1, top - 1, -1):
+                res.append(matrix[i][left])
+            left += 1  # Move the left boundary right
+
+        return res  # Return the spiral order traversal