'''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.







def __UpperCamelCase( _A       :					int     ):
   '''simple docstring'''
   UpperCAmelCase__				:					Tuple 					=	[False] * len(_A     )
   UpperCAmelCase__				:					Dict 					=	[-1] * len(_A     )

   def dfs(_A       :					str	,      _A       :					Dict     ):
      UpperCAmelCase__				:					Any 					=	True
      UpperCAmelCase__				:					int 					=	c
      for u in graph[v]:
         if not visited[u]:
            dfs(_A	,      1 - c     )

   for i in range(len(_A     )     ):
      if not visited[i]:
         dfs(_A	,      0     )

   for i in range(len(_A     )     ):
      for j in graph[i]:
         if color[i] == color[j]:
            return False

   return True


# Adjacency list of graph
UpperCamelCase__  :						List[str]					=      {0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2], 4: []}
print(check_bipartite_dfs(graph))





'''simple docstring'''

from math import factorial, radians







def __UpperCamelCase( _A       :					float	,      _A       :					int = 18	,      _A       :					int = 10     ):
   '''simple docstring'''
   UpperCAmelCase__				:					int 					=	angle_in_degrees - ((angle_in_degrees // 3_6_0.0) * 3_6_0.0)

   # Converting from degrees to radians
   UpperCAmelCase__				:					Dict 					=	radians(_A     )

   UpperCAmelCase__				:					Union[str, Any] 					=	angle_in_radians
   UpperCAmelCase__				:					List[str] 					=	3
   UpperCAmelCase__				:					int 					=	-1

   for _ in range(_A     ):
      result += (b * (angle_in_radians**a)) / factorial(_A     )

      UpperCAmelCase__				:					List[str] 					=	-b  # One positive term and the next will be negative and so on...
      a += 2  # Increased by 2 for every term.

   return round(_A	,      _A     )


if __name__ == "__main__":
  __import__('doctest').testmod()




