
'''simple docstring'''





import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute





def     snake_case							(						UpperCAmelCase = 1 ,					UpperCAmelCase = 1		)->     qiskit.result.counts.Counts:







      """simple docstring"""
      if isinstance(UpperCAmelCase ,					UpperCAmelCase		) or isinstance(UpperCAmelCase ,					UpperCAmelCase		):
            raise TypeError('inputs must be integers.'		)
      if (bit_a < 0) or (bit_a < 0):
            raise ValueError('inputs must be positive.'		)
      if (math.floor(UpperCAmelCase		) != bit_a) or (math.floor(UpperCAmelCase		) != bit_a):
            raise ValueError('inputs must be exact integers.'		)
      if (bit_a > 1) or (bit_a > 1):
            raise ValueError('inputs must be less or equal to 1.'		)

      # build registers
      __A    		=     QuantumRegister(2 ,					'qr'		)
      __A    		=     ClassicalRegister(2 ,					'cr'		)

      __A    		=     QuantumCircuit(UpperCAmelCase ,					UpperCAmelCase		)

      # entanglement the qubits
      quantum_circuit.h(1		)
      quantum_circuit.cx(1 ,					0		)

      # send the information
      __A    		=     str(UpperCAmelCase		) + str(UpperCAmelCase		)

      if c_information == "11":
            quantum_circuit.x(1		)
            quantum_circuit.z(1		)
      elif c_information == "10":
            quantum_circuit.z(1		)
      elif c_information == "01":
            quantum_circuit.x(1		)
      else:
            quantum_circuit.i(1		)

      # unentangled the circuit
      quantum_circuit.cx(1 ,					0		)
      quantum_circuit.h(1		)

      # measure the circuit
      quantum_circuit.measure(UpperCAmelCase ,					UpperCAmelCase		)

      __A    		=     Aer.get_backend('aer_simulator'		)
      __A    		=     execute(UpperCAmelCase ,					UpperCAmelCase ,					shots=1_0_0_0		)

      return job.result().get_counts(UpperCAmelCase		)


if __name__ == "__main__":
 print(f'''Counts for classical state send: {superdense_coding(1,1)}''')








'''simple docstring'''





def     snake_case							(						UpperCAmelCase ,					UpperCAmelCase		)->     Union[str, Any]:







      """simple docstring"""
      print('\nVertex Distance'		)
      for i in range(UpperCAmelCase		):
            if dist[i] != float('inf'		):
                  print(UpperCAmelCase ,					'\t' ,					int(dist[i]		) ,					end='\t'		)
            else:
                  print(UpperCAmelCase ,					'\t' ,					'INF' ,					end='\t'		)
            print()





def     snake_case							(						UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase		)->     List[Any]:







      """simple docstring"""
      __A    		=     float('inf'		)
      __A    		=     -1
      for i in range(UpperCAmelCase		):
            if (not vset[i]) and mdist[i] < min_val:
                  __A    		=     i
                  __A    		=     mdist[i]
      return min_ind





def     snake_case							(						UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase		)->     Dict:







      """simple docstring"""
      __A    		=     [float('inf'		) for _ in range(UpperCAmelCase		)]
      __A    		=     [False for _ in range(UpperCAmelCase		)]
      __A    		=     0.0

      for _ in range(v - 1		):
            __A    		=     min_dist(UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase		)
            __A    		=     True

            for i in range(UpperCAmelCase		):
                  if (
                      (not vset[i])
                      and graph[u][i] != float('inf'		)
                      and mdist[u] + graph[u][i] < mdist[i]
                  ):
                        __A    		=     mdist[u] + graph[u][i]

      print_dist(UpperCAmelCase ,					UpperCAmelCase		)


if __name__ == "__main__":
 a__						:				Tuple           =    int(input("Enter number of vertices: ").strip())
 a__						:				List[str]           =    int(input("Enter number of edges: ").strip())

 a__						:				int           =    [[float("inf") for i in range(V)] for j in range(V)]

 for i in range(V):
  a__						:				Optional[int]           =    0.0

 for i in range(E):
  print("\nEdge ", i + 1)
  a__						:				Union[str, Any]           =    int(input("Enter source:").strip())
  a__						:				Tuple           =    int(input("Enter destination:").strip())
  a__						:				int           =    float(input("Enter weight:").strip())
  a__						:				Dict           =    weight

 a__						:				int           =    int(input("\nEnter shortest path source:").strip())
 dijkstra(graph, V, gsrc)






