


"""simple docstring"""






from collections import defaultdict


class     __lowerCamelCase  :

     '''simple docstring'''


     def __init__(      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase							)       ->							int:
          _a    	=				total  # total no of tasks (N)

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

          _a    	=				defaultdict(__UpperCAmelCase							)  # 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    	=				(1 << len(__UpperCAmelCase							)) - 1


     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase							)       ->							Any:
          # 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
          _a    	=				self.count_ways_until(__UpperCAmelCase    ,				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    	=				total_ways_util

          return self.dp[mask][task_no]





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

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

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









"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__snake_case		=       {
    '''configuration_lxmert''': ['''LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''LxmertConfig'''],
    '''tokenization_lxmert''': ['''LxmertTokenizer'''],
}

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __snake_case		=       ['''LxmertTokenizerFast''']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __snake_case		=       [
       '''LxmertEncoder''',
       '''LxmertForPreTraining''',
       '''LxmertForQuestionAnswering''',
       '''LxmertModel''',
       '''LxmertPreTrainedModel''',
       '''LxmertVisualFeatureEncoder''',
       '''LxmertXLayer''',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   __snake_case		=       [
       '''TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''TFLxmertForPreTraining''',
       '''TFLxmertMainLayer''',
       '''TFLxmertModel''',
       '''TFLxmertPreTrainedModel''',
       '''TFLxmertVisualFeatureEncoder''',
   ]


if TYPE_CHECKING:
   from .configuration_lxmert import LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, LxmertConfig
   from .tokenization_lxmert import LxmertTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_lxmert_fast import LxmertTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_lxmert import (
          LxmertEncoder,
          LxmertForPreTraining,
          LxmertForQuestionAnswering,
          LxmertModel,
          LxmertPreTrainedModel,
          LxmertVisualFeatureEncoder,
          LxmertXLayer,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_lxmert import (
          TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFLxmertForPreTraining,
          TFLxmertMainLayer,
          TFLxmertModel,
          TFLxmertPreTrainedModel,
          TFLxmertVisualFeatureEncoder,
      )

else:
   import sys

   __snake_case		=       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)