





from collections import defaultdict





class  A__    :




   """simple docstring"""



   def __init__(					self					,  lowercase					,  lowercase)			->						Dict:







          '''simple docstring'''

          a__						:	Optional[int] =				total  # total no of tasks (N)

          # DP table will have a dimension of (2^M)*N
          # initially all values are set to -1
          a__						:	List[str] =				[
              [-1 for i in range(total + 1)] for j in range(2 ** len(lowercase))
          ]

          a__						:	Optional[int] =				defaultdict(lowercase)  # stores the list of persons for each task

          # final_mask is used to check if all persons are included by setting all bits
          # to 1
          a__						:	Optional[int] =				(1 << len(lowercase)) - 1

   def 							__lowercase		(					self					,  lowercase					,  lowercase)			->						str:







          '''simple docstring'''

          if mask == self.final_mask:
                 return 1

          # if not everyone gets the task and no more tasks are available, return 0
          if task_no > self.total_tasks:
                 return 0

          # if case already considered
          if self.dp[mask][task_no] != -1:
                 return self.dp[mask][task_no]

          # Number of ways when we don't this task in the arrangement
          a__						:	str =				self.count_ways_until(lowercase					,  task_no + 1)

          # now assign the tasks one by one to all possible persons and recursively
          # assign for the remaining tasks.
          if task_no in self.task:
                 for p in self.task[task_no]:
                        # if p is already given a task
                        if mask & (1 << p):
                               continue

                        # assign this task to p and change the mask value. And recursively
                        # assign tasks with the new mask value.
                        total_ways_util += self.count_ways_until(mask | (1 << p)					,  task_no + 1)

        # save the value.
          a__						:	int =				total_ways_util

          return self.dp[mask][task_no]

   def 							__lowercase		(					self					,  lowercase)			->						Optional[int]:







          '''simple docstring'''

          for i in range(len(lowercase)):
                 for j in task_performed[i]:
                        self.task[j].append(lowercase)

        # call the function to fill the DP table, final answer is stored in dp[0][1]
          return self.count_ways_until(0					,  1)


if __name__ == "__main__":
    lowercase      :       Union[str, Any]									=  5  # total no of tasks (the value of N)

    # the list of tasks that can be done by M persons.
    lowercase      :       Tuple									=  [[1, 3, 4], [1, 2, 5], [3, 4]]
    print(
        AssignmentUsingBitmask(task_performed, total_tasks).count_no_of_ways(
            task_performed
        )
    )





def 		_lowercase (     lowercase__   ,	lowercase__						):
      return (pointa[0] - pointa[0]) ** 2 + (pointa[1] - pointa[1]) ** 2







def 		_lowercase (     lowercase__   ,	lowercase__=0						):
      return sorted(lowercase__   ,	key=lambda lowercase__						: x[column]						)







def 		_lowercase (     lowercase__   ,	lowercase__   ,	lowercase__=float('''inf'''						)						):

      for i in range(points_counts - 1						):
            for j in range(i + 1   ,	lowercase__						):
                  __lowerCAmelCase					:						List[str]					=					euclidean_distance_sqr(points[i]   ,	points[j]						)
                  if current_dis < min_dis:
                        __lowerCAmelCase					:						Tuple					=					current_dis
      return min_dis







def 		_lowercase (     lowercase__   ,	lowercase__   ,	lowercase__=float('''inf'''						)						):

      for i in range(min(6   ,	points_counts - 1						)   ,	lowercase__						):
            for j in range(max(0   ,	i - 6						)   ,	lowercase__						):
                  __lowerCAmelCase					:						Union[str, Any]					=					euclidean_distance_sqr(points[i]   ,	points[j]						)
                  if current_dis < min_dis:
                        __lowerCAmelCase					:						int					=					current_dis
      return min_dis







def 		_lowercase (     lowercase__   ,	lowercase__   ,	lowercase__						):

      # base case
      if points_counts <= 3:
            return dis_between_closest_pair(lowercase__   ,	lowercase__						)

      # recursion
      __lowerCAmelCase					:						Optional[Any]					=					points_counts // 2
      __lowerCAmelCase					:						Optional[Any]					=					closest_pair_of_points_sqr(
          lowercase__   ,	points_sorted_on_y[:mid]   ,	lowercase__						)
      __lowerCAmelCase					:						str					=					closest_pair_of_points_sqr(
          lowercase__   ,	points_sorted_on_y[mid:]   ,	points_counts - mid						)
      __lowerCAmelCase					:						Optional[int]					=					min(lowercase__   ,	lowercase__						)
      __lowerCAmelCase					:						Tuple					=					[]
      for point in points_sorted_on_x:
            if abs(point[0] - points_sorted_on_x[mid][0]						) < closest_pair_dis:
                  cross_strip.append(lowercase__						)

      __lowerCAmelCase					:						List[Any]					=					dis_between_closest_in_strip(
          lowercase__   ,	len(lowercase__						)   ,	lowercase__						)
      return min(lowercase__   ,	lowercase__						)







def 		_lowercase (     lowercase__   ,	lowercase__						):
      __lowerCAmelCase					:						Union[str, Any]					=					column_based_sort(lowercase__   ,	column=0						)
      __lowerCAmelCase					:						Any					=					column_based_sort(lowercase__   ,	column=1						)
      return (
          closest_pair_of_points_sqr(
              lowercase__   ,	lowercase__   ,	lowercase__						)
      ) ** 0.5


if __name__ == "__main__":
 _UpperCamelCase 			=		[(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (3, 4)]
 print("Distance:", closest_pair_of_points(points, len(points)))


