


'''simple docstring'''



class 						_snake_case   :




     def __init__( self							,							_lowerCamelCase):
        UpperCAmelCase__					:   int       				=       set_counts
        UpperCAmelCase__					:   Optional[int]       				=       max(_lowerCamelCase)
        UpperCAmelCase__					:   List[str]       				=       len(_lowerCamelCase)
        UpperCAmelCase__					:   Any       				=       [1] * num_sets
        UpperCAmelCase__					:   List[Any]       				=       list(range(_lowerCamelCase))




     def 			snake_case__  ( self							,							_lowerCamelCase							,							_lowerCamelCase):
        UpperCAmelCase__					:   Any       				=       self.get_parent(_lowerCamelCase)
        UpperCAmelCase__					:   List[str]       				=       self.get_parent(_lowerCamelCase)

        if src_parent == dst_parent:
           return False

        if self.ranks[dst_parent] >= self.ranks[src_parent]:
           self.set_counts[dst_parent] += self.set_counts[src_parent]
           UpperCAmelCase__					:   Dict       				=       0
           UpperCAmelCase__					:   Tuple       				=       dst_parent
           if self.ranks[dst_parent] == self.ranks[src_parent]:
              self.ranks[dst_parent] += 1
           UpperCAmelCase__					:   Optional[int]       				=       self.set_counts[dst_parent]
        else:
           self.set_counts[src_parent] += self.set_counts[dst_parent]
           UpperCAmelCase__					:   str       				=       0
           UpperCAmelCase__					:   int       				=       src_parent
           UpperCAmelCase__					:   List[str]       				=       self.set_counts[src_parent]

        UpperCAmelCase__					:   Dict       				=       max(self.max_set							,							_lowerCamelCase)
        return True




     def 			snake_case__  ( self							,							_lowerCamelCase):
        if self.parents[disj_set] == disj_set:
           return disj_set
        UpperCAmelCase__					:   str       				=       self.get_parent(self.parents[disj_set])
        return self.parents[disj_set]



'''simple docstring'''



import functools







def       _UpperCamelCase (						UpperCamelCase__	, UpperCamelCase__   ):

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

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

			if len(UpperCamelCase__   ) == 0:
						return 0

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

			if max(UpperCamelCase__   ) >= 3_6_6:
						raise ValueError("""All days elements should be less than 366"""   )

			UpperCAmelCase__					:   Union[str, Any]       				=       set(UpperCamelCase__   )

			@functools.cache
			def dynamic_programming(UpperCamelCase__   ) -> int:
						if index > 3_6_5:
									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 + 3_0   )	, )

			return dynamic_programming(1   )


if __name__ == "__main__":
		import doctest

		doctest.testmod()