






# 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 					SCREAMING_SNAKE_CASE    (			snake_case_ :							Optional[int]       ):
	snake_case__			:				Optional[Any]       =  [False] * len(snake_case_       )
	snake_case__			:				Optional[Any]       =  [-1] * len(snake_case_       )

	def dfs(snake_case_ :							List[str]					,  snake_case_ :							Dict       ):
		snake_case__			:				Tuple       =  True
		snake_case__			:				List[str]       =  c
		for u in graph[v]:
			if not visited[u]:
				dfs(snake_case_					,  1 - c       )

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

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

	return True


# Adjacency list of graph
__lowerCamelCase :      str										=				{0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2], 4: []}





print(check_bipartite_dfs(graph))











from __future__ import annotations







def 					SCREAMING_SNAKE_CASE    (			snake_case_ :							float					,  snake_case_ :							float					,  snake_case_ :							float       ):
	if days_between_payments <= 0:
		raise ValueError("days_between_payments must be > 0"       )
	if daily_interest_rate < 0:
		raise ValueError("daily_interest_rate must be >= 0"       )
	if principal <= 0:
		raise ValueError("principal must be > 0"       )
	return principal * daily_interest_rate * days_between_payments







def 					SCREAMING_SNAKE_CASE    (			snake_case_ :							float					,  snake_case_ :							float					,  snake_case_ :							float					,  ):
	if number_of_compounding_periods <= 0:
		raise ValueError("number_of_compounding_periods must be > 0"       )
	if nominal_annual_interest_rate_percentage < 0:
		raise ValueError("nominal_annual_interest_rate_percentage must be >= 0"       )
	if principal <= 0:
		raise ValueError("principal must be > 0"       )

	return principal * (
	    (1 + nominal_annual_interest_rate_percentage) ** number_of_compounding_periods
	    - 1
	)







def 					SCREAMING_SNAKE_CASE    (			snake_case_ :							float					,  snake_case_ :							float					,  snake_case_ :							float					,  ):
	if number_of_years <= 0:
		raise ValueError("number_of_years must be > 0"       )
	if nominal_annual_percentage_rate < 0:
		raise ValueError("nominal_annual_percentage_rate must be >= 0"       )
	if principal <= 0:
		raise ValueError("principal must be > 0"       )

	return compound_interest(
	    snake_case_					,  nominal_annual_percentage_rate / 365					,  number_of_years * 365       )


if __name__ == "__main__":
	import doctest

	doctest.testmod()



