

'''simple docstring'''





from collections import defaultdict


class  UpperCAmelCase :

		'''simple docstring'''






		def __init__(					self   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_		)  ->     Union[str, Any]:






							'''simple docstring'''



							lowerCamelCase_  				=      total  # total no of tasks (N)

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

							lowerCamelCase_  				=      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
							lowerCamelCase_  				=      (1 << len(SCREAMING_SNAKE_CASE_		)) - 1
		def 			UpperCamelCase(					self   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_		)  ->     str:






							'''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
							lowerCamelCase_  				=      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.
							lowerCamelCase_  				=      total_ways_util

							return self.dp[mask][task_no]






		def 			UpperCamelCase(					self   ,			SCREAMING_SNAKE_CASE_		)  ->     List[Any]:






							'''simple docstring'''



							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__":
				A_	= 5  # total no of tasks (the value of N)

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






'''simple docstring'''




import qiskit


def    lowerCamelCase__		(    SCREAMING_SNAKE_CASE   : int							, SCREAMING_SNAKE_CASE   : int    ):
  UpperCAmelCase    				=						qiskit.Aer.get_backend('aer_simulator'    )

  # Create a Quantum Circuit acting on the q register
  UpperCAmelCase    				=						qiskit.QuantumCircuit(SCREAMING_SNAKE_CASE							, SCREAMING_SNAKE_CASE    )

  # Map the quantum measurement to the classical bits
  circuit.measure([0]							, [0]    )

  # Execute the circuit on the simulator
  UpperCAmelCase    				=						qiskit.execute(SCREAMING_SNAKE_CASE							, SCREAMING_SNAKE_CASE							, shots=1000    )

  # Return the histogram data of the results of the experiment.
  return job.result().get_counts(SCREAMING_SNAKE_CASE    )


if __name__ == "__main__":
  print(F'''Total count for various states are: {single_qubit_measure(1, 1)}''')


