



'''simple docstring'''



from collections import defaultdict





class _UpperCamelCase		:





				'''simple docstring'''





				def __init__(							self  :  str  ,       _lowerCAmelCase  :  Dict  ,       _lowerCAmelCase  :  str):







											'''simple docstring'''

											__lowercase       	=total  # total no of tasks (N)

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

											__lowercase       	=defaultdict(_lowerCAmelCase)  # 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
											__lowercase       	=(1 << len(_lowerCAmelCase)) - 1

				def 				__lowerCamelCase     (							self  :  List[Any]  ,       _lowerCAmelCase  :  List[str]  ,       _lowerCAmelCase  :  int):







											'''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
											__lowercase       	=self.count_ways_until(_lowerCAmelCase  ,       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.
											__lowercase       	=total_ways_util

											return self.dp[mask][task_no]

				def 				__lowerCamelCase     (							self  :  Dict  ,       _lowerCAmelCase  :  Union[str, Any]):







											'''simple docstring'''

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

        # 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'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


lowerCamelCase	 =       {
    """configuration_mask2former""": [
        """MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """Mask2FormerConfig""",
    ],
}

try:
		if not is_vision_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowerCamelCase	 =       ["""Mask2FormerImageProcessor"""]

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowerCamelCase	 =       [
		    """MASK2FORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
		    """Mask2FormerForUniversalSegmentation""",
		    """Mask2FormerModel""",
		    """Mask2FormerPreTrainedModel""",
		]

if TYPE_CHECKING:
		from .configuration_maskaformer import MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, MaskaFormerConfig

		try:
				if not is_vision_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .image_processing_maskaformer import MaskaFormerImageProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_maskaformer import (
				    MASK2FORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
				    MaskaFormerForUniversalSegmentation,
				    MaskaFormerModel,
				    MaskaFormerPreTrainedModel,
				)


else:
		import sys

		lowerCamelCase	 =       _LazyModule(__name__, globals()["""__file__"""], _import_structure)



