code: 
  
  
  """simple docstring"""
  
  
  
  
  import heapq
  
  
  
  
  
  def 			a_   (  lowercase__   :str, lowercase__   :str, lowercase__   :List[str]    ):
  							__lowerCamelCase        =			[(0, start)]  # cost from start node,end node
  							__lowerCamelCase        =			set()
  							while heap:
  														((__lowerCamelCase)    ,(__lowerCamelCase))        =			heapq.heappop(_A    )
  														if u in visited:
  																					continue
  														visited.add(_A    )
  														if u == end:
  																					return cost
  														for v, c in graph[u]:
  																					if v in visited:
  																												continue
  																					__lowerCamelCase        =			cost + c
  																					heapq.heappush(_A, (next_item, v)    )
  							return -1
  
  
  __magic_name__	:   Tuple          =							{
      'A': [['B', 2], ['C', 5]],
      'B': [['A', 2], ['D', 3], ['E', 1], ['F', 1]],
      'C': [['A', 5], ['F', 3]],
      'D': [['B', 3]],
      'E': [['B', 4], ['F', 3]],
      'F': [['C', 3], ['E', 3]],
  }
  __magic_name__	:   Optional[Any]          =							{
      'B': [['C', 1]],
      'C': [['D', 1]],
      'D': [['F', 1]],
      'E': [['B', 1], ['F', 3]],
      'F': [],
  }
  __magic_name__	:   int          =							{
      'B': [['C', 1]],
      'C': [['D', 1]],
      'D': [['F', 1]],
      'E': [['B', 1], ['G', 2]],
      'F': [],
      'G': [['F', 1]],
  }
  
  __magic_name__	:   Union[str, Any]          =							dijkstra(G, 'E', 'C')
  print(short_distance)  # E -- 3 --> F -- 3 --> C == 6
  
  __magic_name__	:   Any          =							dijkstra(Ga, 'E', 'F')
  print(short_distance)  # E -- 3 --> F == 3
  
  __magic_name__	:   Union[str, Any]          =							dijkstra(Ga, 'E', 'F')
  print(short_distance)  # E -- 2 --> G -- 1 --> F == 3
  
  if __name__ == "__main__":
  					import doctest
  
  					doctest.testmod()
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  import numpy as np
  
  
  
  
  
  def 			a_   (  lowercase__   :List[str]    ):
  			__lowerCamelCase        =			np.exp(lowercase__    )
  
  			# Add up the all the exponentials
  			__lowerCamelCase        =			np.sum(lowercase__    )
  
  			# Divide every exponent by the sum of all exponents
  			__lowerCamelCase        =			exponent_vector / sum_of_exponents
  
  			return softmax_vector
  
  
  if __name__ == "__main__":
  					print(softmax((0,)))
  
  
  
  
  