




import math
import sys



class 						lowercase_					:



      def __init__(    self   :       Any	)					->  Any:
        _snake_case		=							0
        _snake_case		=							[]
        _snake_case		=							{}  # To store the pos of node in array



      def 		UpperCamelCase_	(    self   :       str	)					->  List[Any]:
        return self.cur_size == 0



      def 		UpperCamelCase_	(    self   :       str    ,      A__   :       List[str]	)					->  List[Any]:
        _snake_case		=							self.left(A__	)
        _snake_case		=							self.right(A__	)
        if lc < self.cur_size and self.array(A__	)[0] < self.array(A__	)[0]:
          _snake_case		=							lc
        else:
          _snake_case		=							idx
        if rc < self.cur_size and self.array(A__	)[0] < self.array(A__	)[0]:
          _snake_case		=							rc
        if smallest != idx:
          self.swap(A__    ,      A__	)
          self.min_heapify(A__	)



      def 		UpperCamelCase_	(    self   :       Dict    ,      A__   :       List[Any]	)					->  Optional[int]:
        # Inserts a node into the Priority Queue
        _snake_case		=							self.cur_size
        self.cur_size += 1
        self.array.append((sys.maxsize, tup[1])	)
        self.decrease_key((sys.maxsize, tup[1])    ,      tup[0]	)



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



      def 		UpperCamelCase_	(    self   :       int    ,      A__   :       Union[str, Any]	)					->  Union[str, Any]:
        # returns the index of left child
        return 2 * i + 1



      def 		UpperCamelCase_	(    self   :       int    ,      A__   :       Dict	)					->  Optional[int]:
        # returns the index of right child
        return 2 * i + 2



      def 		UpperCamelCase_	(    self   :       Optional[int]    ,      A__   :       str	)					->  Union[str, Any]:
        # returns the index of parent
        return math.floor(i / 2	)



      def 		UpperCamelCase_	(    self   :       List[str]    ,      A__   :       Any    ,      A__   :       str	)					->  List[Any]:
        # swaps array elements at indices i and j
        # update the pos{}
        _snake_case		=							j
        _snake_case		=							i
        _snake_case		=							self.array[i]
        _snake_case		=							self.array[j]
        _snake_case		=							temp







      def 		UpperCamelCase_	(    self   :       Union[str, Any]    ,      A__   :       Any    ,      A__   :       str	)					->  Tuple:
        _snake_case		=							self.pos[tup[1]]
        # assuming the new_d is atmost old_d
        _snake_case		=							(new_d, tup[1])
        while idx > 0 and self.array[self.par(A__	)][0] > self.array[idx][0]:
          self.swap(A__    ,      self.par(A__	)	)
          _snake_case		=							self.par(A__	)



class 						lowercase_					:



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



      def 		UpperCamelCase_	(    self   :       Any    ,      A__   :       Union[str, Any]    ,      A__   :       Optional[Any]    ,      A__   :       Any	)					->  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:
          _snake_case		=							[(v, w)]

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



      def 		UpperCamelCase_	(    self   :       Dict	)					->  Optional[Any]:
        # u -> v(w)
        for u in self.adjList:
          print(A__    ,      '''->'''    ,      ''' -> '''.join(str(f"""{v}({w})"""	) for v, w in self.adjList[u]	)	)



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

        while not q.is_empty():
          _snake_case		=							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]:
            _snake_case		=							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__	)
              _snake_case		=							new_dist
              _snake_case		=							u

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



      def 		UpperCamelCase_	(    self   :       Any    ,      A__   :       List[str]	)					->  Dict:
        print(f"""Distance from node: {src}"""	)
        for u in range(self.num_nodes	):
          print(f"""Node {u} has distance: {self.dist[u]}"""	)







      def 		UpperCamelCase_	(    self   :       Any    ,      A__   :       Tuple    ,      A__   :       List[Any]	)					->  Any:
        # To show the shortest path from src to dest
        # WARNING: Use it *after* calling dijkstra
        _snake_case		=							[]
        _snake_case		=							0
        _snake_case		=							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
          _snake_case		=							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__":
 __A    	=			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, 11)
 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, 14)
 graph.add_edge(4, 5, 10)
 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 numpy as np



def    snake_case_(_UpperCamelCase  )							->			Any:



  """simple docstring"""






  _snake_case		=							np.exp(_UpperCamelCase  )

  # Add up the all the exponentials
  _snake_case		=							np.sum(_UpperCamelCase  )

  # Divide every exponent by the sum of all exponents
  _snake_case		=							exponent_vector / sum_of_exponents

  return softmax_vector


if __name__ == "__main__":
 print(softmax((0,)))

