


import math
import sys


class        A_					:




      '''simple docstring'''


      def __init__(				self:       str				):
       __lowerCamelCase		:							Any							=						0
       __lowerCamelCase		:							Optional[Any]							=						[]
       __lowerCamelCase		:							Tuple							=						{}  # To store the pos of node in array




      def      _snake_case	(				self:       Dict				):
       return self.cur_size == 0




      def      _snake_case	(				self:       str						,      a:       int				):
       __lowerCamelCase		:							Dict							=						self.left(a				)
       __lowerCamelCase		:							List[Any]							=						self.right(a				)
       if lc < self.cur_size and self.array(a				)[0] < self.array(a				)[0]:
        __lowerCamelCase		:							Union[str, Any]							=						lc
       else:
        __lowerCamelCase		:							Optional[int]							=						idx
       if rc < self.cur_size and self.array(a				)[0] < self.array(a				)[0]:
        __lowerCamelCase		:							List[Any]							=						rc
       if smallest != idx:
        self.swap(a						,      a				)
        self.min_heapify(a				)




      def      _snake_case	(				self:       Union[str, Any]						,      a:       List[str]				):
       # Inserts a node into the Priority Queue
       __lowerCamelCase		:							int							=						self.cur_size
       self.cur_size += 1
       self.array.append((sys.maxsize, tup[1])				)
       self.decrease_key((sys.maxsize, tup[1])						,      tup[0]				)




      def      _snake_case	(				self:       List[Any]				):
       # Removes and returns the min element at top of priority queue
       __lowerCamelCase		:							int							=						self.array[0][1]
       __lowerCamelCase		:							Optional[Any]							=						self.array[self.cur_size - 1]
       self.cur_size -= 1
       self.min_heapify(1				)
       del self.pos[min_node]
       return min_node




      def      _snake_case	(				self:       Optional[Any]						,      a:       Optional[int]				):
       # returns the index of left child
       return 2 * i + 1




      def      _snake_case	(				self:       Tuple						,      a:       Optional[int]				):
       # returns the index of right child
       return 2 * i + 2




      def      _snake_case	(				self:       Optional[int]						,      a:       Dict				):
       # returns the index of parent
       return math.floor(i / 2				)




      def      _snake_case	(				self:       Any						,      a:       List[str]						,      a:       Optional[int]				):
       # swaps array elements at indices i and j
       # update the pos{}
       __lowerCamelCase		:							Optional[int]							=						j
       __lowerCamelCase		:							List[str]							=						i
       __lowerCamelCase		:							List[str]							=						self.array[i]
       __lowerCamelCase		:							Optional[int]							=						self.array[j]
       __lowerCamelCase		:							str							=						temp




      def      _snake_case	(				self:       Any						,      a:       int						,      a:       Any				):
       __lowerCamelCase		:							List[str]							=						self.pos[tup[1]]
       # assuming the new_d is atmost old_d
       __lowerCamelCase		:							int							=						(new_d, tup[1])
       while idx > 0 and self.array[self.par(a				)][0] > self.array[idx][0]:
        self.swap(a						,      self.par(a				)				)
        __lowerCamelCase		:							Dict							=						self.par(a				)



class        A_					:




      '''simple docstring'''


      def __init__(				self:       str						,      a:       str				):
       __lowerCamelCase		:							Any							=						{}  # To store graph: u -> (v,w)
       __lowerCamelCase		:							Any							=						num  # Number of nodes in graph
       # To store the distance from source vertex
       __lowerCamelCase		:							int							=						[0] * self.num_nodes
       __lowerCamelCase		:							Any							=						[-1] * self.num_nodes  # To store the path




      def      _snake_case	(				self:       Union[str, Any]						,      a:       Dict						,      a:       Union[str, Any]						,      a:       List[Any]				):
       #  Edge going from node u to v and v to u with weight w
       # u (w)-> v, v (w) -> u
       # Check if u already in graph
       if u in self.adjList:
        self.adjList[u].append((v, w)				)
       else:
        __lowerCamelCase		:							List[Any]							=						[(v, w)]

       # Assuming undirected graph
       if v in self.adjList:
        self.adjList[v].append((u, w)				)
       else:
        __lowerCamelCase		:							List[Any]							=						[(u, w)]




      def      _snake_case	(				self:       List[str]				):
       # u -> v(w)
       for u in self.adjList:
        print(a						,      '->'						,      ' -> '.join(str(F'{v}({w})'				) for v, w in self.adjList[u]				)				)




      def      _snake_case	(				self:       int						,      a:       Optional[int]				):
       # Flush old junk values in par[]
       __lowerCamelCase		:							Optional[Any]							=						[-1] * self.num_nodes
       # src is the source node
       __lowerCamelCase		:							Any							=						0
       __lowerCamelCase		:							List[Any]							=						PriorityQueue()
       q.insert((0, src)				)  # (dist from src, node)
       for u in self.adjList:
        if u != src:
         __lowerCamelCase		:							Optional[int]							=						sys.maxsize  # Infinity
         __lowerCamelCase		:							Dict							=						-1

       while not q.is_empty():
        __lowerCamelCase		:							List[str]							=						q.extract_min()  # Returns node with the min dist from source
        # Update the distance of all the neighbours of u and
        # if their prev dist was INFINITY then push them in Q
        for v, w in self.adjList[u]:
         __lowerCamelCase		:							Optional[Any]							=						self.dist[u] + w
         if self.dist[v] > new_dist:
          if self.dist[v] == sys.maxsize:
           q.insert((new_dist, v)				)
          else:
           q.decrease_key((self.dist[v], v)						,      a				)
          __lowerCamelCase		:							Union[str, Any]							=						new_dist
          __lowerCamelCase		:							Optional[int]							=						u

        # Show the shortest distances from src
       self.show_distances(a				)




      def      _snake_case	(				self:       str						,      a:       List[Any]				):
       print(F'Distance from node: {src}'				)
       for u in range(self.num_nodes				):
        print(F'Node {u} has distance: {self.dist[u]}'				)




      def      _snake_case	(				self:       List[Any]						,      a:       int						,      a:       List[Any]				):
       # To show the shortest path from src to dest
       # WARNING: Use it *after* calling dijkstra
       __lowerCamelCase		:							Optional[int]							=						[]
       __lowerCamelCase		:							Dict							=						0
       __lowerCamelCase		:							Optional[int]							=						dest
       # Backtracking from dest to src
       while self.par[temp] != -1:
        path.append(a				)
        if temp != src:
         for v, w in self.adjList[temp]:
          if v == self.par[temp]:
           cost += w
           break
        __lowerCamelCase		:							Union[str, Any]							=						self.par[temp]
       path.append(a				)
       path.reverse()

       print(F'----Path to reach {dest} from {src}----'				)
       for u in path:
        print(F'{u}'						,      end=' '				)
        if u != dest:
         print('-> '						,      end=''				)

       print('\nTotal cost of path: '						,      a				)


if __name__ == "__main__":
       lowercase_           =	Graph(9)
       graph.add_edge(0, 1, 4)
       graph.add_edge(0, 7, 8)
       graph.add_edge(1, 2, 8)
       graph.add_edge(1, 7, 1_1)
       graph.add_edge(2, 3, 7)
       graph.add_edge(2, 8, 2)
       graph.add_edge(2, 5, 4)
       graph.add_edge(3, 4, 9)
       graph.add_edge(3, 5, 1_4)
       graph.add_edge(4, 5, 1_0)
       graph.add_edge(5, 6, 2)
       graph.add_edge(6, 7, 1)
       graph.add_edge(6, 8, 6)
       graph.add_edge(7, 8, 7)
       graph.show_graph()
       graph.dijkstra(0)
       graph.show_path(0, 4)

# OUTPUT
# 0 -> 1(4) -> 7(8)
# 1 -> 0(4) -> 2(8) -> 7(11)
# 7 -> 0(8) -> 1(11) -> 6(1) -> 8(7)
# 2 -> 1(8) -> 3(7) -> 8(2) -> 5(4)
# 3 -> 2(7) -> 4(9) -> 5(14)
# 8 -> 2(2) -> 6(6) -> 7(7)
# 5 -> 2(4) -> 3(14) -> 4(10) -> 6(2)
# 4 -> 3(9) -> 5(10)
# 6 -> 5(2) -> 7(1) -> 8(6)
# Distance from node: 0
# Node 0 has distance: 0
# Node 1 has distance: 4
# Node 2 has distance: 12
# Node 3 has distance: 19
# Node 4 has distance: 21
# Node 5 has distance: 11
# Node 6 has distance: 9
# Node 7 has distance: 8
# Node 8 has distance: 14
# ----Path to reach 4 from 0----
# 0 -> 7 -> 6 -> 5 -> 4
# Total cost of path:  21





import doctest

import projectq
from projectq.ops import H, Measure
def       UpperCamelCase__     (  SCREAMING_SNAKE_CASE__						):
 __lowerCamelCase		:							int							=						quantum_engine.allocate_qubit()
 H | qubit
 Measure | qubit
 return int(SCREAMING_SNAKE_CASE__						)


if __name__ == "__main__":
       doctest.testmod()

       # initialises a new quantum backend
       lowercase_           =	projectq.MainEngine()

       # Generate a list of 10 random numbers
       lowercase_           =	[get_random_number(quantum_engine) for _ in range(1_0)]

       # Flushes the quantum engine from memory
       quantum_engine.flush()

       print('Random numbers', random_numbers_list)

