


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

 for _ in range(v - 1						):
  __lowerCamelCase		:							Any							=						min_dist(SCREAMING_SNAKE_CASE__			,       SCREAMING_SNAKE_CASE__			,       SCREAMING_SNAKE_CASE__						)
  __lowerCamelCase		:							Dict							=						True

  for i in range(SCREAMING_SNAKE_CASE__						):
   if (
       (not vset[i])
       and graph[u][i] != float('inf'						)
       and mdist[u] + graph[u][i] < mdist[i]
   ):
    __lowerCamelCase		:							Union[str, Any]							=						mdist[u] + graph[u][i]

 print_dist(SCREAMING_SNAKE_CASE__			,       SCREAMING_SNAKE_CASE__						)


if __name__ == "__main__":
       lowercase_           =	int(input('Enter number of vertices: ').strip())
       lowercase_           =	int(input('Enter number of edges: ').strip())

       lowercase_           =	[[float('inf') for i in range(V)] for j in range(V)]

       for i in range(V):
              lowercase_           =	0.0

       for i in range(E):
              print('\nEdge ', i + 1)
              lowercase_           =	int(input('Enter source:').strip())
              lowercase_           =	int(input('Enter destination:').strip())
              lowercase_           =	float(input('Enter weight:').strip())
              lowercase_           =	weight

       lowercase_           =	int(input('\nEnter shortest path source:').strip())
       dijkstra(graph, V, gsrc)





class        A_					:




      '''simple docstring'''


      def __init__(				self:       Tuple						,      a:       Dict=None				):
       __lowerCamelCase		:							List[Any]							=						data
       __lowerCamelCase		:							Optional[Any]							=						None




      def __repr__(				self:       Optional[int]				):
       __lowerCamelCase		:							Any							=						''
       __lowerCamelCase		:							List[Any]							=						self
       while temp:
        string_rep += F'<{temp.data}> ---> '
        __lowerCamelCase		:							Any							=						temp.next
       string_rep += "<END>"
       return string_rep



def       UpperCamelCase__     (  SCREAMING_SNAKE_CASE__						):

 # if elements_list is empty
 if not elements_list:
  raise Exception('The Elements List is empty'						)

 # Set first element as Head
 __lowerCamelCase		:							Optional[int]							=						Node(elements_list[0]						)
 __lowerCamelCase		:							List[str]							=						head
 # Loop through elements from position 1
 for data in elements_list[1:]:
  __lowerCamelCase		:							str							=						Node(SCREAMING_SNAKE_CASE__						)
  __lowerCamelCase		:							Tuple							=						current.next
 return head


lowercase_           =	[1, 3, 5, 3_2, 4_4, 1_2, 4_3]
print(F"""List: {list_data}""")
print('Creating Linked List from List.')
lowercase_           =	make_linked_list(list_data)
print('Linked List:')



print(linked_list)

