





from collections import defaultdict


class 						lowerCamelCase       :







							"""simple docstring"""




							def __init__( self     :					Dict,			_UpperCAmelCase     :					int,			_UpperCAmelCase     :					List[Any]						)				->			int:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Dict     =						total  # total no of tasks (N)

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

														SCREAMING_SNAKE_CASE__       :      Dict     =						defaultdict(__A						)  # 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
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						(1 << len(__A						)) - 1






							def  A_     ( self     :					Tuple,			_UpperCAmelCase     :					List[Any],			_UpperCAmelCase     :					List[Any]						)				->			List[Any]:





														"""simple docstring"""
														# 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
														SCREAMING_SNAKE_CASE__       :      List[str]     =						self.count_ways_until(__A,			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.
														SCREAMING_SNAKE_CASE__       :      int     =						total_ways_util

														return self.dp[mask][task_no]






							def  A_     ( self     :					Tuple,			_UpperCAmelCase     :					Union[str, Any]						)				->			str:





														"""simple docstring"""
														# Store the list of persons for each task
														for i in range(len(__A						)						):
																					for j in task_performed[i]:
																												self.task[j].append(__A						)

																					 # 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 :    List[str]  							= 5  # total no of tasks (the value of N)

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













class 						lowerCamelCase       :







							"""simple docstring"""




							def __init__( self     :					int,			_UpperCAmelCase     :					Dict,			_UpperCAmelCase     :					str						)				->			Optional[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      str     =						name
														SCREAMING_SNAKE_CASE__       :      Tuple     =						val






							def __str__( self     :					str						)				->			List[Any]:





														"""simple docstring"""
														return F'''{self.__class__.__name__}({self.name}, {self.val})'''






							def __lt__( self     :					str,			_UpperCAmelCase     :					Dict						)				->			Union[str, Any]:





														"""simple docstring"""
														return self.val < other.val


class 						lowerCamelCase       :







							"""simple docstring"""




							def __init__( self     :					Optional[Any],			_UpperCAmelCase     :					str						)				->			Tuple:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						{}
														SCREAMING_SNAKE_CASE__       :      str     =						{}
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						self.build_heap(_UpperCAmelCase						)






							def __getitem__( self     :					Union[str, Any],			_UpperCAmelCase     :					Any						)				->			Dict:





														"""simple docstring"""
														return self.get_value(_UpperCAmelCase						)






							def  A_     ( self     :					int,			_UpperCAmelCase     :					Optional[int]						)				->			Any:





														"""simple docstring"""
														return (idx - 1) // 2






							def  A_     ( self     :					Optional[Any],			_UpperCAmelCase     :					Any						)				->			Dict:





														"""simple docstring"""
														return idx * 2 + 1






							def  A_     ( self     :					str,			_UpperCAmelCase     :					List[str]						)				->			Union[str, Any]:





														"""simple docstring"""
														return idx * 2 + 2






							def  A_     ( self     :					Tuple,			_UpperCAmelCase     :					int						)				->			Optional[int]:





														"""simple docstring"""
														return self.heap_dict[key]






							def  A_     ( self     :					Optional[int],			_UpperCAmelCase     :					Dict						)				->			Optional[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[str]     =						len(_UpperCAmelCase						) - 1
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						self.get_parent_idx(_UpperCAmelCase						)

														for idx, i in enumerate(_UpperCAmelCase						):
																					SCREAMING_SNAKE_CASE__       :      Optional[int]     =						idx
																					SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						i.val

														for i in range(_UpperCAmelCase,			-1,			-1						):
																					self.sift_down(_UpperCAmelCase,			_UpperCAmelCase						)
														return array






							def  A_     ( self     :					List[Any],			_UpperCAmelCase     :					Dict,			_UpperCAmelCase     :					Tuple						)				->			Tuple:





														"""simple docstring"""
														while True:
																					SCREAMING_SNAKE_CASE__       :      str     =						self.get_left_child_idx(_UpperCAmelCase						)  # noqa: E741
																					SCREAMING_SNAKE_CASE__       :      Tuple     =						self.get_right_child_idx(_UpperCAmelCase						)

																					SCREAMING_SNAKE_CASE__       :      Tuple     =						idx
																					if l < len(_UpperCAmelCase						) and array[l] < array[idx]:
																												SCREAMING_SNAKE_CASE__       :      List[Any]     =						l
																					if r < len(_UpperCAmelCase						) and array[r] < array[smallest]:
																												SCREAMING_SNAKE_CASE__       :      int     =						r

																					if smallest != idx:
																												SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      Any     =						array[smallest], array[idx]
																												(
																												    (
																												    SCREAMING_SNAKE_CASE__
																												)   ,(
																												    SCREAMING_SNAKE_CASE__
																												)   ,
																												)       :      Optional[Any]     =						(
																												    self.idx_of_element[array[smallest]],
																												    self.idx_of_element[array[idx]],
																												)
																												SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						smallest
																					else:
																												break






							def  A_     ( self     :					Union[str, Any],			_UpperCAmelCase     :					str						)				->			Any:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Any     =						self.get_parent_idx(_UpperCAmelCase						)
														while p >= 0 and self.heap[p] > self.heap[idx]:
																					SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      Any     =						self.heap[idx], self.heap[p]
																					SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      int     =						(
																					    self.idx_of_element[self.heap[idx]],
																					    self.idx_of_element[self.heap[p]],
																					)
																					SCREAMING_SNAKE_CASE__       :      Dict     =						p
																					SCREAMING_SNAKE_CASE__       :      List[str]     =						self.get_parent_idx(_UpperCAmelCase						)






							def  A_     ( self     :					str						)				->			List[str]:





														"""simple docstring"""
														return self.heap[0]






							def  A_     ( self     :					Tuple						)				->			List[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      Optional[int]     =						self.heap[-1], self.heap[0]
														SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      List[Any]     =						(
														    self.idx_of_element[self.heap[-1]],
														    self.idx_of_element[self.heap[0]],
														)

														SCREAMING_SNAKE_CASE__       :      Any     =						self.heap.pop()
														del self.idx_of_element[x]
														self.sift_down(0,			self.heap						)
														return x






							def  A_     ( self     :					Union[str, Any],			_UpperCAmelCase     :					str						)				->			Optional[Any]:





														"""simple docstring"""
														self.heap.append(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      str     =						len(self.heap						) - 1
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						node.val
														self.sift_up(len(self.heap						) - 1						)






							def  A_     ( self     :					Optional[int]						)				->			int:





														"""simple docstring"""
														return len(self.heap						) == 0






							def  A_     ( self     :					Any,			_UpperCAmelCase     :					Tuple,			_UpperCAmelCase     :					str						)				->			Dict:





														"""simple docstring"""
														assert (
														    self.heap[self.idx_of_element[node]].val > new_value
														), "newValue must be less that current value"
														SCREAMING_SNAKE_CASE__       :      Tuple     =						new_value
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						new_value
														self.sift_up(self.idx_of_element[node]						)


_lowerCamelCase :    Tuple  							= Node('''R''', -1)
_lowerCamelCase :    int  							= Node('''B''', 6)
_lowerCamelCase :    str  							= Node('''A''', 3)
_lowerCamelCase :    Optional[Any]  							= Node('''X''', 1)
_lowerCamelCase :    str  							= Node('''E''', 4)

# Use one of these two ways to generate Min-Heap

# Generating Min-Heap from array
_lowerCamelCase :    int  							= MinHeap([r, b, a, x, e])

# Generating Min-Heap by Insert method
# myMinHeap.insert(a)
# myMinHeap.insert(b)
# myMinHeap.insert(x)
# myMinHeap.insert(r)
# myMinHeap.insert(e)

# Before
print('''Min Heap - before decrease key''')
for i in my_min_heap.heap:
		print(i)

print('''Min Heap - After decrease key of node [B -> -17]''')
my_min_heap.decrease_key(b, -1_7)

# After
for i in my_min_heap.heap:
		print(i)

if __name__ == "__main__":
		import doctest

		doctest.testmod()






