





from collections import defaultdict







class      lowerCamelCase:
     '''simple docstring'''


     def __init__(    self				,     snake_case_				,     snake_case_							):
         _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(snake_case_							)							)
         ]

         _A     =							defaultdict(snake_case_							)  # 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(snake_case_							)) - 1




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_							):
         # 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(snake_case_				,     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        lowerCAmelCase__		(    self				,     snake_case_							):
         # Store the list of persons for each task
         for i in range(len(snake_case_							)							):
             for j in task_performed[i]:
                 self.task[j].append(snake_case_							)

        # 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__":
 __A							:			Optional[int]         =			5  # total no of tasks (the value of N)

 # the list of tasks that can be done by M persons.
 __A							:			Any         =			[[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

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A__    :   List[str]           =					{
    '''configuration_autoformer''': [
        '''AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''AutoformerConfig''',
    ],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    A__    :   Optional[Any]           =					[
        '''AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''AutoformerForPrediction''',
        '''AutoformerModel''',
        '''AutoformerPreTrainedModel''',
    ]


if TYPE_CHECKING:
    from .configuration_autoformer import (
        AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
        AutoformerConfig,
    )

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_autoformer import (
            AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
            AutoformerForPrediction,
            AutoformerModel,
            AutoformerPreTrainedModel,
        )

else:
    import sys

    A__    :   Optional[int]           =					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



