



# 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 						_UpperCAmelCase							( snake_case     ):





					"""simple docstring"""

					_lowerCAmelCase         =       Queue()
					_lowerCAmelCase         =       [False] * len(snake_case     )
					_lowerCAmelCase         =       [-1] * len(snake_case     )

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

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

																				if color[neighbour] == -1:
																									_lowerCAmelCase         =       1 - color[u]
																									queue.put(snake_case     )

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

										return True

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





'''simple docstring'''







def       _a		(						_SCREAMING_SNAKE_CASE		: str	):
						_SCREAMING_SNAKE_CASE					=			len(_SCREAMING_SNAKE_CASE	)
						for i in range(length - 1	):
												_SCREAMING_SNAKE_CASE					=			False
												for j in range(length - 1 - i	):
																		if collection[j] > collection[j + 1]:
																								_SCREAMING_SNAKE_CASE					=			True
																								_SCREAMING_SNAKE_CASE,				_SCREAMING_SNAKE_CASE					=			collection[j + 1], collection[j]
												if not swapped:
																		break  # Stop iteration if the collection is sorted.
						return collection


if __name__ == "__main__":
						import doctest
						import time

						doctest.testmod()

						_snake_case					: Union[str, Any]     			=					input("""Enter numbers separated by a comma:""").strip()
						_snake_case					: List[Any]     			=					[int(item) for item in user_input.split(""",""")]
						_snake_case					: Optional[int]     			=					time.process_time()
						print(*bubble_sort(unsorted), sep=""",""")
						print(F"Processing time: {(time.process_time() - start)%1E9 + 7}")