





'''simple docstring'''




from heapq import heappop, heappush

import numpy as np







def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase       ,    )->     tuple[float | int, list[tuple[int, int]]]:
 __UpperCAmelCase					,    __UpperCAmelCase					=   grid.shape
 __UpperCAmelCase					=   [-1, 1, 0, 0]
 __UpperCAmelCase					=   [0, 0, -1, 1]
 if allow_diagonal:
  dx += [-1, -1, 1, 1]
  dy += [-1, 1, -1, 1]

 __UpperCAmelCase					,    __UpperCAmelCase					=   [(0, source)], set()
 __UpperCAmelCase					=   np.full((rows, cols)       ,    np.inf    )
 __UpperCAmelCase					=   0
 __UpperCAmelCase					=   np.empty((rows, cols)       ,    dtype=_lowerCAmelCase    )
 __UpperCAmelCase					=   None

 while queue:
  ((__UpperCAmelCase)					,    (__UpperCAmelCase))					=   heappop(_lowerCAmelCase    )
  if (x, y) in visited:
   continue
  visited.add((x, y)    )

  if (x, y) == destination:
   __UpperCAmelCase					=   []
   while (x, y) != source:
    path.append((x, y)    )
    __UpperCAmelCase					,    __UpperCAmelCase					=   predecessors[x, y]
   path.append(_lowerCAmelCase    )  # add the source manually
   path.reverse()
   return matrix[destination], path

  for i in range(len(_lowerCAmelCase    )    ):
   __UpperCAmelCase					,    __UpperCAmelCase					=   x + dx[i], y + dy[i]
   if 0 <= nx < rows and 0 <= ny < cols:
    __UpperCAmelCase					=   grid[nx][ny]
    if next_node == 1 and matrix[nx, ny] > dist + 1:
     heappush(_lowerCAmelCase       ,    (dist + 1, (nx, ny))    )
     __UpperCAmelCase					=   dist + 1
     __UpperCAmelCase					=   (x, y)

 return np.inf, []


if __name__ == "__main__":
    import doctest

    doctest.testmod()












'''simple docstring'''




import math

import numpy as np
import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute







def _lowerCAmelCase     (      _lowerCAmelCase = 3    )->     qiskit.result.counts.Counts:
 if isinstance(_lowerCAmelCase       ,    _lowerCAmelCase    ):
  raise TypeError('number of qubits must be a integer.'    )
 if number_of_qubits <= 0:
  raise ValueError('number of qubits must be > 0.'    )
 if math.floor(_lowerCAmelCase    ) != number_of_qubits:
  raise ValueError('number of qubits must be exact integer.'    )
 if number_of_qubits > 10:
  raise ValueError('number of qubits too large to simulate(>10).'    )

 __UpperCAmelCase					=   QuantumRegister(_lowerCAmelCase       ,    'qr'    )
 __UpperCAmelCase					=   ClassicalRegister(_lowerCAmelCase       ,    'cr'    )

 __UpperCAmelCase					=   QuantumCircuit(_lowerCAmelCase       ,    _lowerCAmelCase    )

 __UpperCAmelCase					=   number_of_qubits

 for i in range(_lowerCAmelCase    ):
  quantum_circuit.h(number_of_qubits - i - 1    )
  counter -= 1
  for j in range(_lowerCAmelCase    ):
   quantum_circuit.cp(np.pi / 2 ** (counter - j)       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )

 for k in range(number_of_qubits // 2    ):
  quantum_circuit.swap(_lowerCAmelCase       ,    number_of_qubits - k - 1    )

 # measure all the qubits
 quantum_circuit.measure(_lowerCAmelCase       ,    _lowerCAmelCase    )
 # simulate with 10000 shots
 __UpperCAmelCase					=   Aer.get_backend('qasm_simulator'    )
 __UpperCAmelCase					=   execute(_lowerCAmelCase       ,    _lowerCAmelCase       ,    shots=1_00_00    )

 return job.result().get_counts(_lowerCAmelCase    )


if __name__ == "__main__":
    print(
        F"""Total count for quantum fourier transform state is: \
    {quantum_fourier_transform(3)}"""
    )





