





def 	A_       (  _lowerCAmelCase							,     _lowerCAmelCase  )		->				Dict:
 print("\nThe shortest path matrix using Floyd Warshall algorithm\n"  )
 for i in range(_lowerCAmelCase  ):
  for j in range(_lowerCAmelCase  ):
   if dist[i][j] != float("inf"  ):
    print(int(dist[i][j]  )							,     end="\t"  )
   else:
    print("INF"							,     end="\t"  )
  print()



def 	A_       (  _lowerCAmelCase							,     _lowerCAmelCase  )		->				Union[str, Any]:
 UpperCamelCase			:      Dict			=     [[float("inf"  ) for _ in range(_lowerCAmelCase  )] for _ in range(_lowerCAmelCase  )]

 for i in range(_lowerCAmelCase  ):
  for j in range(_lowerCAmelCase  ):
   UpperCamelCase			:      List[Any]			=     graph[i][j]

   # check vertex k against all other vertices (i, j)
 for k in range(_lowerCAmelCase  ):
  # looping through rows of graph array
  for i in range(_lowerCAmelCase  ):
   # looping through columns of graph array
   for j in range(_lowerCAmelCase  ):
    if (
        dist[i][k] != float("inf"  )
        and dist[k][j] != float("inf"  )
        and dist[i][k] + dist[k][j] < dist[i][j]
    ):
     UpperCamelCase			:      Union[str, Any]			=     dist[i][k] + dist[k][j]

 _print_dist(_lowerCAmelCase							,     _lowerCAmelCase  )
 return dist, v


if __name__ == "__main__":
    __lowerCamelCase :  Optional[Any]										=  int(input("""Enter number of vertices: """))
    __lowerCamelCase :  int										=  int(input("""Enter number of edges: """))

    __lowerCamelCase :  Any										=  [[float("""inf""") for i in range(v)] for j in range(v)]

    for i in range(v):
        __lowerCamelCase :  Dict										=  0.0

        # src and dst are indices that must be within the array size graph[e][v]
        # failure to follow this will result in an error
    for i in range(e):
        print("""\nEdge """, i + 1)
        __lowerCamelCase :  Union[str, Any]										=  int(input("""Enter source:"""))
        __lowerCamelCase :  Dict										=  int(input("""Enter destination:"""))
        __lowerCamelCase :  str										=  float(input("""Enter weight:"""))
        __lowerCamelCase :  str										=  weight

    floyd_warshall(graph, v)

    # Example Input
    # Enter number of vertices: 3
    # Enter number of edges: 2

    # # generated graph from vertex and edge inputs
    # [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
    # [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

    # specify source, destination and weight for edge #1
    # Edge  1
    # Enter source:1
    # Enter destination:2
    # Enter weight:2

    # specify source, destination and weight for edge #2
    # Edge  2
    # Enter source:2
    # Enter destination:1
    # Enter weight:1

    # # Expected Output from the vertice, edge and src, dst, weight inputs!!
    # 0		INF	INF
    # INF	0	2
    # INF	1	0







from typing import Callable, Optional

from .. import Features
from ..packaged_modules.generator.generator import Generator
from .abc import AbstractDatasetInputStream



class       A__     ( __snake_case    ):





      def __init__(				self ,							A_ ,							A_ = None ,							A_ = None ,							A_ = False ,							A_ = False ,							A_ = None ,							A_ = None ,							**A_ ,							):
       '''simple docstring'''




       super().__init__(
           features=A_ ,							cache_dir=A_ ,							keep_in_memory=A_ ,							streaming=A_ ,							num_proc=A_ ,							**A_ ,							)
       UpperCamelCase			:      Optional[int] 			=     Generator(
           cache_dir=A_ ,							features=A_ ,							generator=A_ ,							gen_kwargs=A_ ,							**A_ ,							)





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       if self.streaming:
        UpperCamelCase			:      Optional[Any] 			=     self.builder.as_streaming_dataset(split="train"     )
       # Build regular (map-style) dataset
       else:
        UpperCamelCase			:      Union[str, Any] 			=     None
        UpperCamelCase			:      Union[str, Any] 			=     None
        UpperCamelCase			:      List[Any] 			=     None
        UpperCamelCase			:      List[str] 			=     None

        self.builder.download_and_prepare(
            download_config=A_ ,							download_mode=A_ ,							verification_mode=A_ ,							base_path=A_ ,							num_proc=self.num_proc ,							)
        UpperCamelCase			:      int 			=     self.builder.as_dataset(
            split="train" ,							verification_mode=A_ ,							in_memory=self.keep_in_memory     )
       return dataset
