


'''simple docstring'''
# 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 				lowerCAmelCase__	(       UpperCAmelCase     ):






       """simple docstring"""





       snake_case__					:	Dict          =					Queue()
       snake_case__					:	Optional[Any]          =					[False] * len(lowerCAmelCase_     )
       snake_case__					:	Union[str, Any]          =					[-1] * len(lowerCAmelCase_     )

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

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

                            if color[neighbour] == -1:
                                   snake_case__					:	List[str]          =					1 - color[u]
                                   queue.put(lowerCAmelCase_     )

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

              return True

       for i in range(len(lowerCAmelCase_     )     ):
              if not visited[i]:
                     queue.put(lowerCAmelCase_     )
                     snake_case__					:	Union[str, Any]          =					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]}))








def       lowerCAmelCase			(		lowerCAmelCase_			)->			int:
				lowerCAmelCase_			:   Optional[int]     					=					len(lowerCAmelCase_			)
				if n in (0, 1):
								return 0
				return sum(query * (n - i - 1) for i, query in enumerate(sorted(lowerCAmelCase_			)			)			)


if __name__ == "__main__":
						import doctest

						doctest.testmod()