





"""simple docstring"""


from collections import defaultdict



class      __SCREAMING_SNAKE_CASE    :







  '''simple docstring'''


  def __init__(		self   :       str					,   __a   :       List[str]					,   __a   :       Tuple	)		->				Optional[Any]:
        _UpperCamelCase      :	Optional[Any]						=       total  # total no of tasks (N)

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

        _UpperCamelCase      :	List[Any]						=       defaultdict(__a	)  # 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
        _UpperCamelCase      :	List[Any]						=       (1 << len(__a	)) - 1

  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[int]					,   __a   :       Optional[int]					,   __a   :       Any	)		->				Optional[int]:
        # if mask == self.finalmask all persons are distributed tasks, return 1
        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
        _UpperCamelCase      :	Optional[Any]						=       self.count_ways_until(__a					,   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.
        _UpperCamelCase      :	Union[str, Any]						=       total_ways_util

        return self.dp[mask][task_no]


  def    __SCREAMING_SNAKE_CASE				(		self   :       str					,   __a   :       Tuple	)		->				List[str]:
        # Store the list of persons for each task
        for i in range(len(__a	)	):
              for j in task_performed[i]:
                    self.task[j].append(__a	)

        # 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__":
  lowerCamelCase__				  =   5  # total no of tasks (the value of N)

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







"""simple docstring"""


lowerCamelCase__				  =   "\n# Installazione di Transformers\n! pip install transformers datasets\n# Per installare dalla fonte invece dell'ultima versione rilasciata, commenta il comando sopra e\n# rimuovi la modalità commento al comando seguente.\n# ! pip install git+https://github.com/huggingface/transformers.git\n"

lowerCamelCase__				  =   [{"type": "code", "content": INSTALL_CONTENT}]
lowerCamelCase__				  =   {
    "{processor_class}": "FakeProcessorClass",
    "{model_class}": "FakeModelClass",
    "{object_class}": "FakeObjectClass",
}
