modified: graphs/check_bipartite_graph_all.py

Author: shivaparihar6119

Diff for: graphs/check_bipartite_graph_all.py

@@ -1,122 +1,88 @@
-from collections import defaultdict
-from queue import Queue
+from collections import defaultdict, deque
 
-
-def check_bipartite(graph: dict[int, list[int]]) -> bool:
+def is_bipartite_dfs(graph: defaultdict[int, list[int]]) -> bool:
     """
-    Check if a graph is Bipartite using Depth-First Search.
+    Check graph bipartite using DFS.
 
     Args:
-        graph: Adjacency list representing the graph.
+        graph (defaultdict[int, list[int]]): Adjacency list.
 
     Returns:
-        bool: True if no edge connects same set vertices.
+        bool: True if bipartite, False otherwise.
+
+    Divides graph into two sets without same-set connections.
 
     Examples:
-        >>> is_bipartite(defaultdict(list, {0: [1, 2], 1: [0, 3], ...}))
-        False
-        >>> is_bipartite(defaultdict(list, {0: [1, 2], 1: [0, 2], 2: [0, 1]}))
-        True
+    >>> is_bipartite_dfs(defaultdict(list, {0: [1, 2], 1: [0, 3], 2: [0, 4]}))
+    True
+    >>> is_bipartite_dfs(defaultdict(list, {0: [1, 2], 1: [0, 2], 2: [0, 1]}))
+    False
     """
-    queue: Queue = Queue()
-    visited = [False] * len(graph)
-    color = [-1] * len(graph)
-
-    def bfs() -> bool:
+    def dfs(node, color):
         """
-        Perform Breadth-First Search (BFS) on a graph to check if it's bipartite.
+        DFS starting from a node.
 
         Args:
-            graph (dict[int, list[int]]): An adjacency list representing the graph.
+            node: Current node.
+            color: Color assigned to the current node.
 
         Returns:
-            bool: True if there's no edge, False otherwise.
+            bool: True if bipartite starting from the current node.
 
         Examples:
-            >>> bfs({0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2]})
-            True
-            >>> bfs({0: [1, 2, 3], 1: [0, 2], 2: [0, 1, 3], 3: [0, 2]})
-            False
+        >>> dfs(0, 0, defaultdict(list, {0: [1, 2], 1: [0, 3], 2: [0, 4]}))
+        True
+        >>> dfs(0, 0, defaultdict(list, {0: [1, 2], 1: [0, 2], 2: [0, 1]}))
+        False
         """
-        while not queue.empty():
-            u = queue.get()
-            visited[u] = True
-
-            for neighbour in graph[u]:
-                if neighbour == u:
+        if visited[node] == -1:
+            visited[node] = color
+            for neighbor in graph[node]:
+                if not dfs(neighbor, 1 - color):
                     return False
+        return visited[node] == color
 
-                if color[neighbour] == -1:
-                    color[neighbour] = 1 - color[u]
-                    queue.put(neighbour)
-
-                elif color[neighbour] == color[u]:
-                    return False
-
-        return True
-
-    for i in range(len(graph)):
-        if not visited[i]:
-            queue.put(i)
-            color[i] = 0
-            if bfs() is False:
-                return False
-
+    visited = defaultdict(lambda: -1)
+    for node in graph:
+        if visited[node] == -1 and not dfs(node, 0):
+            return False
     return True
 
-
-if __name__ == "__main__":
-    # Adjacency List of graph
-    print(check_bipartite({0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2]}))
-
-
-def is_bipartite(graph: defaultdict[int, list[int]]) -> bool:
+def is_bipartite_bfs(graph: defaultdict[int, list[int]]) -> bool:
     """
-    Check if a graph is Bipartite using Breadth-First Search.
+    Check graph bipartite using BFS.
 
     Args:
-        graph: Adjacency list representing the graph.
+        graph (defaultdict[int, list[int]]): Adjacency list.
 
     Returns:
-        bool: True if no edge connects same set vertices.
+        bool: True if bipartite, False otherwise.
+
+    Divides graph into two sets without same-set connections.
 
     Examples:
-        >>> check_bipartite({0: [1, 3], 1: [0, 2], 2: [1, 3], ...})
-        True
-        >>> check_bipartite({0: [1, 2, 3], 1: [0, 2], ...})
-        False
+    >>> is_bipartite_bfs(defaultdict(list, {0: [1, 2], 1: [0, 3], 2: [0, 4]}))
+    True
+    >>> is_bipartite_bfs(defaultdict(list, {0: [1, 2], 1: [0, 2], 2: [0, 1]}))
+    False
     """
+    visited = defaultdict(lambda: -1)
+    for node in graph:
+        if visited[node] == -1:
+            queue = deque()
+            queue.append(node)
+            visited[node] = 0
+            while queue:
+                curr_node = queue.popleft()
+                for neighbor in graph[curr_node]:
+                    if visited[neighbor] == -1:
+                        visited[neighbor] = 1 - visited[curr_node]
+                        queue.append(neighbor)
+                    elif visited[neighbor] == visited[curr_node]:
+                        return False
+    return True
 
-    def dfs(node: int, color: int) -> bool:
-        """
-        Perform depth-first search from a node with specified color.
-
-        Args:
-            node (int): Current node being visited.
-            color (int): Color assigned to the current node.
-
-        Returns:
-            bool: True if the graph is bipartite fromcurrent node,else False.
-
-        Examples:
-            >>> dfs(0, 0, defaultdict(list, {0: [1, 2], ...}))
-            False
-            >>> dfs(0, 0, defaultdict(list, {0: [1, 2], 1: [0, 2], ...}))
-            True
-        """
-        visited[node] = color
-        return any(
-            visited[neighbour] == color
-            or (visited[neighbour] == -1 and not dfs(neighbour, 1 - color))
-            for neighbour in graph[node]
-        )
-
-    visited: defaultdict[int, int] = defaultdict(lambda: -1)
-
-    return all(not (visited[node] == -1 and not dfs(node, 0)) for node in graph)
-
-
-if __name__ == "__main__":
+if __name__ == "__main":
     import doctest
 
     result = doctest.testmod()
@@ -125,4 +91,3 @@ def dfs(node: int, color: int) -> bool:
         print(f"{result.failed} test(s) failed.")
     else:
         print("All tests passed!")
-