





from __future__ import annotations


def     SCREAMING_SNAKE_CASE			(      lowerCAmelCase    ,       lowerCAmelCase					):
       print(f'''Vertex\tShortest Distance from vertex {src}'''					)
       for i, d in enumerate(lowerCAmelCase					):
              print(f'''{i}\t\t{d}'''					)


def     SCREAMING_SNAKE_CASE			(      lowerCAmelCase    ,       lowerCAmelCase    ,       lowerCAmelCase					):
       for j in range(lowerCAmelCase					):
              _UpperCamelCase       ,		_UpperCamelCase       ,		_UpperCamelCase              =						(graph[j][k] for k in ['''src''', '''dst''', '''weight'''])
              if distance[u] != float('''inf'''					) and distance[u] + w < distance[v]:
                     return True
       return False


def     SCREAMING_SNAKE_CASE			(      lowerCAmelCase    ,       lowerCAmelCase    ,       lowerCAmelCase    ,       lowerCAmelCase					):
       _UpperCamelCase              =						[float('''inf'''					)] * vertex_count
       _UpperCamelCase              =						0.0

       for _ in range(vertex_count - 1					):
              for j in range(lowerCAmelCase					):
                     _UpperCamelCase       ,		_UpperCamelCase       ,		_UpperCamelCase              =						(graph[j][k] for k in ['''src''', '''dst''', '''weight'''])

                     if distance[u] != float('''inf'''					) and distance[u] + w < distance[v]:
                            _UpperCamelCase              =						distance[u] + w

       _UpperCamelCase              =						check_negative_cycle(lowerCAmelCase    ,       lowerCAmelCase    ,       lowerCAmelCase					)
       if negative_cycle_exists:
              raise Exception('''Negative cycle found'''					)

       return distance


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       lowercase    : Optional[Any]    	=  int(input("""Enter number of vertices: """).strip())
       lowercase    : List[str]    	=  int(input("""Enter number of edges: """).strip())

       lowercase    : list[dict[str, int]]    	=  [{} for _ in range(E)]

       for i in range(E):
              print("""Edge """, i + 1)
              lowercase	,lowercase	,lowercase    : int    	=  (
                  int(x)
                  for x in input("""Enter source, destination, weight: """).strip().split(""" """)
              )
              lowercase    : Dict    	=  {"""src""": src, """dst""": dest, """weight""": weight}

       lowercase    : Optional[int]    	=  int(input("""\nEnter shortest path source:""").strip())
       lowercase    : Any    	=  bellman_ford(graph, V, E, source)
       print_distance(shortest_distance, 0)













from __future__ import annotations

lowercase    : int    	=  {
    """A""": ["""B""", """C""", """E"""],
    """B""": ["""A""", """D""", """E"""],
    """C""": ["""A""", """F""", """G"""],
    """D""": ["""B"""],
    """E""": ["""A""", """B""", """D"""],
    """F""": ["""C"""],
    """G""": ["""C"""],
}

class  __A:

     def __init__(      self,       A,       A      ):





            """simple docstring"""

            _UpperCamelCase              =						graph
            # mapping node to its parent in resulting breadth first tree
            _UpperCamelCase              =						{}
            _UpperCamelCase              =						source_vertex

     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            _UpperCamelCase              =						{self.source_vertex}
            _UpperCamelCase              =						None
            _UpperCamelCase              =						[self.source_vertex]  # first in first out queue

            while queue:
                   _UpperCamelCase              =						queue.pop(0      )
                   for adjacent_vertex in self.graph[vertex]:
                          if adjacent_vertex not in visited:
                                 visited.add(A      )
                                 _UpperCamelCase              =						vertex
                                 queue.append(A      )



     def 	_UpperCamelCase     (      self,       A      ):





            """simple docstring"""

            if target_vertex == self.source_vertex:
                   return self.source_vertex

            _UpperCamelCase              =						self.parent.get(A      )
            if target_vertex_parent is None:
                   _UpperCamelCase              =						(
                       F'''No path from vertex: {self.source_vertex} to vertex: {target_vertex}'''
                   )
                   raise ValueError(A      )

            return self.shortest_path(A      ) + F'''->{target_vertex}'''


if __name__ == "__main__":
       lowercase    : Tuple    	=  Graph(graph, """G""")
       g.breath_first_search()
       print(g.shortest_path("""D"""))
       print(g.shortest_path("""G"""))
       print(g.shortest_path("""Foo"""))






