fixes#8098

Author: shivaparihar6119

Diff for: graphs/check_bipartite_graph_all.py

@@ -1,93 +1,101 @@
-from collections import defaultdict, deque
+from queue import Queue
+from collections import defaultdict
 
-def is_bipartite_dfs(graph: defaultdict[int, list[int]]) -> bool:
+def check_bipartite(graph: dict[int, list[int]])->bool:
     """
-    Check graph bipartite using DFS.
+    Check graph bipartite using BFS.
 
     Args:
-        graph (defaultdict[int, list[int]]): Adjacency list.
+        graph (dict[int, List[int]]): Adjacency list.
 
     Returns:
         bool: True if bipartite, False otherwise.
 
     Divides graph into two sets without same-set connections.
 
     Examples:
-    >>> is_bipartite_dfs(defaultdict(list, {0: [1, 2], 1: [0, 3], 2: [0, 4]}))
+    >>> check_bipartite(dict(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]}))
+    >>> check_bipartite(dict(list, {0: [1, 2], 1: [0, 2], 2: [0, 1]}))
     False
     """
-    def dfs(node, color):
-        """
-        DFS starting from a node.
-
-        Args:
-            node: Current node.
-            color: Color assigned to the current node.
+    queue:Queue() = Queue()
+    visited = [False] * len(graph)
+    color = [-1] * len(graph)
 
-        Returns:
-            bool: True if bipartite starting from the current node.
+    def bfs()->bool:
+        while not queue.empty():
+            u = queue.get()
+            visited[u] = True
 
-        Examples:
-        >>> 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
-        """
-        if visited[node] == -1:
-            visited[node] = color
-            for neighbor in graph[node]:
-                if not dfs(neighbor, 1 - color):
+            for neighbour in graph[u]:
+                if neighbour == u:
                     return False
-        return visited[node] == color
 
-    visited = defaultdict(lambda: -1)
-    for node in graph:
-        if visited[node] == -1 and not dfs(node, 0):
-            return False
-    return True
+                if color[neighbour] == -1:
+                    color[neighbour] = 1 - color[u]
+                    queue.put(neighbour)
 
-def is_bipartite_bfs(graph: defaultdict[int, list[int]]) -> bool:
+                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
+    return True
+def is_bipartite(graph: defaultdict[int, list[int]]) -> bool:
     """
-    Check graph bipartite using BFS.
+    Check whether a graph is Bipartite or not using Depth-First Search (DFS).
+
+    A Bipartite Graph is a graph whose vertices can be divided into two independent
+    sets, U and V such that every edge (u, v) either connects a vertex from
+    U to V or a vertex from V to U. In other words, for every edge (u, v),
+    either u belongs to U and v to V, or u belongs to V and v to U. There is
+    no edge that connects vertices of the same set.
 
     Args:
-        graph (defaultdict[int, list[int]]): Adjacency list.
+        graph: An adjacency list representing the graph.
 
     Returns:
-        bool: True if bipartite, False otherwise.
-
-    Divides graph into two sets without same-set connections.
+        True if there's no edge that connects vertices of the same set, False otherwise.
 
     Examples:
-    >>> 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
+        >>> is_bipartite(
+        ...     defaultdict(list, {0: [1, 2], 1: [0, 3], 2: [0, 4], 3: [1], 4: [2]})
+        ... )
+        False
+        >>> is_bipartite(defaultdict(list, {0: [1, 2], 1: [0, 2], 2: [0, 1]}))
+        True
     """
-    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
 
-if __name__ == "__main":
+    def depth_first_search(node: int, color: int) -> bool:
+        visited[node] = color
+        return any(
+            visited[neighbour] == color
+            or (
+                visited[neighbour] == -1
+                and not depth_first_search(neighbour, 1 - color)
+            )
+            for neighbour in graph[node]
+        )
+
+    visited: defaultdict[int, int] = defaultdict(lambda: -1)
+
+    return all(
+        not (visited[node] == -1 and not depth_first_search(node, 0)) for node in graph
+    )
+
+
+if __name__ == "__main__":
     import doctest
 
     result = doctest.testmod()
 
     if result.failed:
         print(f"{result.failed} test(s) failed.")
     else:
-        print("All tests passed!")
+        print("All tests passed!")