


'''simple docstring'''
def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





       print("""\nVertex Distance"""     )
       for i in range(_A     ):
              if dist[i] != float("""inf"""     ):
                     print(_A    ,       """\t"""    ,       int(dist[i]     )    ,       end="""\t"""     )
              else:
                     print(_A    ,       """\t"""    ,       """INF"""    ,       end="""\t"""     )
              print()



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





       snake_case__					:	Union[str, Any]          =					float("""inf"""     )
       snake_case__					:	Dict          =					-1
       for i in range(_A     ):
              if (not vset[i]) and mdist[i] < min_val:
                     snake_case__					:	List[str]          =					i
                     snake_case__					:	int          =					mdist[i]
       return min_ind



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





       snake_case__					:	Any          =					[float("""inf"""     ) for _ in range(_A     )]
       snake_case__					:	List[Any]          =					[False for _ in range(_A     )]
       snake_case__					:	str          =					0.0

       for _ in range(v - 1     ):
              snake_case__					:	int          =					min_dist(_A    ,       _A    ,       _A     )
              snake_case__					:	str          =					True

              for i in range(_A     ):
                     if (
                         (not vset[i])
                         and graph[u][i] != float("""inf"""     )
                         and mdist[u] + graph[u][i] < mdist[i]
                     ):
                            snake_case__					:	Any          =					mdist[u] + graph[u][i]

       print_dist(_A    ,       _A     )


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

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

     for i in range(V):
          lowerCAmelCase__  =     0.0

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

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












'''simple docstring'''


from itertools import combinations_with_replacement







def 						__magic_name__(			_A = 100       ):
						'''simple docstring'''





						UpperCamelCase__       =			[*list(range(1    ,   21       )       ), 25]
						UpperCamelCase__       =			[2 * x for x in range(1    ,   21       )] + [50]
						UpperCamelCase__       =			[3 * x for x in range(1    ,   21       )]
						UpperCamelCase__       =			singles + doubles + triples + [0]

						UpperCamelCase__       =			0
						UpperCamelCase__       =			42
						UpperCamelCase__       =			42
						UpperCamelCase__       =			42
						UpperCamelCase__       =			42

						for double in doubles:
												for throwa, throwa in combinations_with_replacement(_A    ,   2       ):
																		UpperCamelCase__       =			double + throwa + throwa
																		if checkout_total < limit:
																								num_checkouts += 1

						return num_checkouts


if __name__ == "__main__":
					print(f"""{solution() = }""")
