
def        __lowercase(							__snake_case				:		int    ,__snake_case				:		List[Any]					)       ->   Dict:
       print('\nVertex Distance'					)
       for i in range(__snake_case					):
              if dist[i] != float('inf'					):
                     print(__snake_case    ,'\t'    ,int(dist[i]					)    ,end='\t'					)
              else:
                     print(__snake_case    ,'\t'    ,'INF'    ,end='\t'					)
              print()
def        __lowercase(							__snake_case				:		Union[str, Any]    ,__snake_case				:		Union[str, Any]    ,__snake_case				:		List[str]					)       ->   int:
       __snake_case						       =   float('inf'					)
       __snake_case						       =   -1
       for i in range(__snake_case					):
              if (not vset[i]) and mdist[i] < min_val:
                     __snake_case						       =   i
                     __snake_case						       =   mdist[i]
       return min_ind
def        __lowercase(							__snake_case				:		Dict    ,__snake_case				:		Tuple    ,__snake_case				:		Tuple					)       ->   Optional[Any]:
       __snake_case						       =   [float('inf'					) for _ in range(__snake_case					)]
       __snake_case						       =   [False for _ in range(__snake_case					)]
       __snake_case						       =   0.0

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

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

       print_dist(__snake_case    ,__snake_case					)


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

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

 for i in range(V):
  lowerCamelCase_				:							Any       =    0.0

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

 lowerCamelCase_				:							Union[str, Any]       =    int(input("\nEnter shortest path source:").strip())
 dijkstra(graph, V, gsrc)





'''simple docstring'''



def 	__lowerCAmelCase       (				lowerCamelCase :    float					,		lowerCamelCase :    float       ):






	'''simple docstring'''




	__lowerCAmelCase       				=	float()
	try:
		__lowerCAmelCase       				=	mass * acceleration
	except Exception:
		return -0.0
	return force


if __name__ == "__main__":
	import doctest

	# run doctest
	doctest.testmod()

	# demo
	lowerCAmelCase						:		List[Any]						      = 12.5
	lowerCAmelCase						:		Optional[Any]						      = 1_0
	lowerCAmelCase						:		str						      = newtons_second_law_of_motion(mass, acceleration)
	print('''The force is ''', force, '''N''')