

# 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. We can also say that there is no edge that connects
# vertices of same set.
from queue import Queue

def 			__snake_case	(   __UpperCamelCase  :   List[str]						):



      """simple docstring"""

      A_	     =							Queue()
      A_	     =							[False] * len(__UpperCamelCase						)
      A_	     =							[-1] * len(__UpperCamelCase						)

      def bfs():
            while not queue.empty():
                  A_	     =							queue.get()
                  A_	     =							True

                  for neighbour in graph[u]:
                        if neighbour == u:
                              return False

                        if color[neighbour] == -1:
                              A_	     =							1 - color[u]
                              queue.put(__UpperCamelCase						)

                        elif color[neighbour] == color[u]:
                              return False

            return True

      for i in range(len(__UpperCamelCase						)						):
            if not visited[i]:
                  queue.put(__UpperCamelCase						)
                  A_	     =							0
                  if bfs() is False:
                        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]}))


import pytest

from datasets.utils.version import Version

@pytest.mark.parametrize(
    "other, expected_equality"							,[
        (Version("1.0.0"						), True),
        ("1.0.0", True),
        (Version("2.0.0"						), False),
        ("2.0.0", False),
        ("1", False),
        ("a", False),
        (1, False),
        (None, False),
    ]							,)
def 			__snake_case	(   __UpperCamelCase  :   Any							,__UpperCamelCase  :   List[Any]						):



      """simple docstring"""

      A_	     =							Version("1.0.0"						)
      assert (version == other) is expected_equality
      assert (version != other) is not expected_equality
      assert (hash(__UpperCamelCase						) == hash(__UpperCamelCase						)) is expected_equality