






# 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       a__						(  A					):
   lowercase__						:	Tuple         = Queue()
   lowercase__						:	Optional[Any]         = [False] * len(A					)
   lowercase__						:	List[Any]         = [-1] * len(A					)

   def bfs():
      while not queue.empty():
         lowercase__						:	int         = queue.get()
         lowercase__						:	Optional[Any]         = True

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

            if color[neighbour] == -1:
               lowercase__						:	str         = 1 - color[u]
               queue.put(A					)

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

      return True

   for i in range(len(A					)					):
      if not visited[i]:
         queue.put(A					)
         lowercase__						:	int         = 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]}))










from __future__ import annotations

from collections.abc import Iterator
from typing import Any
class        __snake_case:



 def __init__(	self   :   Union[str, Any] ,		UpperCAmelCase__   :   Any	):

    """simple docstring"""






    lowercase__						:	Any         = data
    lowercase__						:	Node | None         = None







 def __str__(	self   :   Dict	):

    """simple docstring"""






    return f'''{self.data}'''
class        __snake_case:



 def __init__(	self   :   Optional[Any]	):

    """simple docstring"""






    lowercase__						:	Node | None         = None
    lowercase__						:	Node | None         = None



 def __iter__(	self   :   Any	):

    """simple docstring"""






    lowercase__						:	Any         = self.front
    while node:
       yield node.data
       lowercase__						:	List[str]         = node.next



 def __len__(	self   :   Union[str, Any]	):

    """simple docstring"""






    return len(tuple(iter(self	)	)	)



 def __str__(	self   :   Optional[Any]	):

    """simple docstring"""






    return " <- ".join(str(UpperCAmelCase__	) for item in self	)



 def 						UpperCAmelCase    (	self   :   List[str]	):

    """simple docstring"""






    return len(self	) == 0



 def 						UpperCAmelCase    (	self   :   Optional[int] ,		UpperCAmelCase__   :   Any	):

    """simple docstring"""






    lowercase__						:	List[str]         = Node(UpperCAmelCase__	)
    if self.is_empty():
       lowercase__						:	List[Any]         = node
    else:
       assert isinstance(self.rear ,		UpperCAmelCase__	)
       lowercase__						:	Any         = node
       lowercase__						:	Union[str, Any]         = node



 def 						UpperCAmelCase    (	self   :   List[Any]	):

    """simple docstring"""






    if self.is_empty():
       raise IndexError("""dequeue from empty queue"""	)
    assert isinstance(self.front ,		UpperCAmelCase__	)
    lowercase__						:	Tuple         = self.front
    lowercase__						:	Any         = self.front.next
    if self.front is None:
       lowercase__						:	List[Any]         = None
    return node.data







 def 						UpperCAmelCase    (	self   :   Optional[Any]	):

    """simple docstring"""






    lowercase__						:	List[Any]         = None


if __name__ == "__main__":
 from doctest import testmod

 testmod()


