






'''simple docstring'''
import math







class 	UpperCamelCase__					:

		"""simple docstring"""




		def __init__( self						:						Tuple							,    __A						:						int=0    ):  # a graph with Node 0,1,...,N-1







							"""simple docstring"""
							_lowercase			= n
							_lowercase			= [
							    [math.inf for j in range(0							,    __UpperCamelCase    )] for i in range(0							,    __UpperCamelCase    )
							]  # adjacency matrix for weight
							_lowercase			= [
							    [math.inf for j in range(0							,    __UpperCamelCase    )] for i in range(0							,    __UpperCamelCase    )
							]  # dp[i][j] stores minimum distance from i to j




		def       snake_case     ( self						:						Optional[Any]							,    __A						:						Union[str, Any]							,    __A						:						Any							,    __A						:						Optional[int]    ):







							"""simple docstring"""
							_lowercase			= w




		def       snake_case     ( self						:						Any    ):







							"""simple docstring"""


							for k in range(0							,    self.n    ):
												for i in range(0							,    self.n    ):
																	for j in range(0							,    self.n    ):
																						_lowercase			= min(self.dp[i][j]							,    self.dp[i][k] + self.dp[k][j]    )




		def       snake_case     ( self						:						str							,    __A						:						Union[str, Any]							,    __A						:						Union[str, Any]    ):







							"""simple docstring"""
							return self.dp[u][v]


if __name__ == "__main__":
	__magic_name__		:     Union[str, Any]					=    Graph(5)
	graph.add_edge(0, 2, 9)
	graph.add_edge(0, 4, 10)
	graph.add_edge(1, 3, 5)
	graph.add_edge(2, 3, 7)
	graph.add_edge(3, 0, 10)
	graph.add_edge(3, 1, 2)
	graph.add_edge(3, 2, 1)
	graph.add_edge(3, 4, 6)
	graph.add_edge(4, 1, 3)
	graph.add_edge(4, 2, 4)
	graph.add_edge(4, 3, 9)
	graph.floyd_warshall()
	graph.show_min(1, 4)
	graph.show_min(0, 3)




import functools





def a(lowercase__      ,			lowercase__						):





	'''simple docstring'''

	# Validation
	if not isinstance(lowercase__      ,			lowercase__						) or not all(isinstance(lowercase__      ,			lowercase__						) for day in days						):
		raise ValueError('The parameter days should be a list of integers'						)

	if len(lowercase__						) != 3 or not all(isinstance(lowercase__      ,			lowercase__						) for cost in costs						):
		raise ValueError('The parameter costs should be a list of three integers'						)

	if len(lowercase__						) == 0:
		return 0

	if min(lowercase__						) <= 0:
		raise ValueError('All days elements should be greater than 0'						)

	if max(lowercase__						) >= 366:
		raise ValueError('All days elements should be less than 366'						)

	snake_case_   		=			set(lowercase__						)

	@functools.cache
	def dynamic_programming(lowercase__						) -> int:
		if index > 365:
			return 0

		if index not in days_set:
			return dynamic_programming(index + 1						)

		return min(
		    costs[0] + dynamic_programming(index + 1						)      ,			costs[1] + dynamic_programming(index + 7						)      ,			costs[2] + dynamic_programming(index + 30						)      ,			)

	return dynamic_programming(1						)


if __name__ == "__main__":
		import doctest

		doctest.testmod()
