


"""simple docstring"""






from collections import defaultdict


class 			__lowerCamelCase     :

     '''simple docstring'''


     def __init__(					self			, __UpperCAmelCase			, __UpperCAmelCase							)				->							Union[str, Any]:
          _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(SCREAMING_SNAKE_CASE__							)							)
          ]

          _a					= defaultdict(SCREAMING_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(SCREAMING_SNAKE_CASE__							)) - 1


     def 							_UpperCAmelCase					(					self			, __UpperCAmelCase			, __UpperCAmelCase							)				->							str:
          # 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(SCREAMING_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 							_UpperCAmelCase					(					self			, __UpperCAmelCase							)				->							List[Any]:
          # Store the list of persons for each task
          for i in range(len(SCREAMING_SNAKE_CASE__							)							):
               for j in task_performed[i]:
                    self.task[j].append(SCREAMING_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__":
   __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
       )
   )

from typing import Optional

from .. import Features, NamedSplit
from ..packaged_modules.text.text import Text
from ..utils.typing import NestedDataStructureLike, PathLike
from .abc import AbstractDatasetReader

class    lowerCAmelCase__     (	__lowercase			):






		def __init__(		self		:							Tuple							,			SCREAMING_SNAKE_CASE__		:							NestedDataStructureLike[PathLike]							,			SCREAMING_SNAKE_CASE__		:							Optional[NamedSplit] = None							,			SCREAMING_SNAKE_CASE__		:							Optional[Features] = None							,			SCREAMING_SNAKE_CASE__		:							str = None							,			SCREAMING_SNAKE_CASE__		:							bool = False							,			SCREAMING_SNAKE_CASE__		:							bool = False							,			SCREAMING_SNAKE_CASE__		:							Optional[int] = None							,			**SCREAMING_SNAKE_CASE__		:							str							,			)     ->							Union[str, Any]:
						super().__init__(
						    SCREAMING_SNAKE_CASE__							,			split=SCREAMING_SNAKE_CASE__							,			features=SCREAMING_SNAKE_CASE__							,			cache_dir=SCREAMING_SNAKE_CASE__							,			keep_in_memory=SCREAMING_SNAKE_CASE__							,			streaming=SCREAMING_SNAKE_CASE__							,			num_proc=SCREAMING_SNAKE_CASE__							,			**SCREAMING_SNAKE_CASE__							,			)
						__lowerCamelCase    					=	path_or_paths if isinstance(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  ) else {self.split: path_or_paths}
						__lowerCamelCase    					=	Text(
						    cache_dir=SCREAMING_SNAKE_CASE__							,			data_files=SCREAMING_SNAKE_CASE__							,			features=SCREAMING_SNAKE_CASE__							,			**SCREAMING_SNAKE_CASE__							,			)







		def  __A       (		self		:							int  )     ->							Dict:
						# Build iterable dataset
						if self.streaming:
										__lowerCamelCase    					=	self.builder.as_streaming_dataset(split=self.split  )
						# Build regular (map-style) dataset
						else:
										__lowerCamelCase    					=	None
										__lowerCamelCase    					=	None
										__lowerCamelCase    					=	None
										__lowerCamelCase    					=	None

										self.builder.download_and_prepare(
										    download_config=SCREAMING_SNAKE_CASE__							,			download_mode=SCREAMING_SNAKE_CASE__							,			verification_mode=SCREAMING_SNAKE_CASE__							,			base_path=SCREAMING_SNAKE_CASE__							,			num_proc=self.num_proc							,			)
										__lowerCamelCase    					=	self.builder.as_dataset(
										    split=self.split							,			verification_mode=SCREAMING_SNAKE_CASE__							,			in_memory=self.keep_in_memory  )
						return dataset



