'''simple docstring'''
from collections import defaultdict







class lowerCamelCase							:




  '''simple docstring'''



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

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

        UpperCAmelCase_            =  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
        UpperCAmelCase_            =  (1 << len(UpperCAmelCase__  )) - 1






  def  lowerCAmelCase__ (      self			:       Optional[int]  ,							UpperCAmelCase__			:       int  ,							UpperCAmelCase__			:       Tuple  )				->List[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
        UpperCAmelCase_            =  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.
        UpperCAmelCase_            =  total_ways_util

        return self.dp[mask][task_no]






  def  lowerCAmelCase__ (      self			:       List[str]  ,							UpperCAmelCase__			:       List[Any]  )				->Any:
        # 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__":
       lowercase__  :      int        =					5  # total no of tasks (the value of N)

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






'''simple docstring'''
from __future__ import annotations



def  __lowerCamelCase       (      _UpperCamelCase  :  tuple[int, int]							,    _UpperCamelCase  :  int					):


      '''simple docstring'''


      UpperCAmelCase_      ,		UpperCAmelCase_            =  position
      UpperCAmelCase_            =  [
          (y + 1, x + 2),
          (y - 1, x + 2),
          (y + 1, x - 2),
          (y - 1, x - 2),
          (y + 2, x + 1),
          (y + 2, x - 1),
          (y - 2, x + 1),
          (y - 2, x - 1),
      ]
      UpperCAmelCase_            =  []

      for position in positions:
            UpperCAmelCase_      ,		UpperCAmelCase_            =  position
            if 0 <= y_test < n and 0 <= x_test < n:
                  permissible_positions.append(_UpperCamelCase					)

      return permissible_positions



def  __lowerCamelCase       (      _UpperCamelCase  :  list[list[int]]					):


      '''simple docstring'''


      return not any(elem == 0 for row in board for elem in row					)



def  __lowerCamelCase       (      _UpperCamelCase  :  list[list[int]]							,    _UpperCamelCase  :  tuple[int, int]							,    _UpperCamelCase  :  int					):


      '''simple docstring'''


      if is_complete(_UpperCamelCase					):
            return True

      for position in get_valid_pos(_UpperCamelCase							,    len(_UpperCamelCase					)					):
            UpperCAmelCase_      ,		UpperCAmelCase_            =  position

            if board[y][x] == 0:
                  UpperCAmelCase_            =  curr + 1
                  if open_knight_tour_helper(_UpperCamelCase							,    _UpperCamelCase							,    curr + 1					):
                        return True
                  UpperCAmelCase_            =  0

      return False



def  __lowerCamelCase       (      _UpperCamelCase  :  int					):


      '''simple docstring'''


      UpperCAmelCase_            =  [[0 for i in range(_UpperCamelCase					)] for j in range(_UpperCamelCase					)]

      for i in range(_UpperCamelCase					):
            for j in range(_UpperCamelCase					):
                  UpperCAmelCase_            =  1
                  if open_knight_tour_helper(_UpperCamelCase							,    (i, j)							,    1					):
                        return board
                  UpperCAmelCase_            =  0

      UpperCAmelCase_            =  F"""Open Kight Tour cannot be performed on a board of size {n}"""
      raise ValueError(_UpperCamelCase					)


if __name__ == "__main__":
      import doctest

      doctest.testmod()





