


'''simple docstring'''


def      lowerCamelCase					(      lowerCamelCase  :      List[str]							,						lowerCamelCase  :      Optional[Any]):
      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      lowerCamelCase					(      lowerCamelCase  :      Optional[int]							,						lowerCamelCase  :      Union[str, Any]):
      A_						:  Optional[int]          =				[[float("""inf""") for _ in range(lowerCamelCase)] for _ in range(lowerCamelCase)]

      for i in range(lowerCamelCase):
            for j in range(lowerCamelCase):
                  A_						:  List[str]          =				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]
                        ):
                              A_						:  Tuple          =				dist[i][k] + dist[k][j]

      _print_dist(lowerCamelCase							,						lowerCamelCase)
      return dist, v


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

     __magic_name__			=      [[float('inf') for i in range(v)] for j in range(v)]

     for i in range(v):
          __magic_name__			=      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)
          __magic_name__			=      int(input('Enter source:'))
          __magic_name__			=      int(input('Enter destination:'))
          __magic_name__			=      float(input('Enter weight:'))
          __magic_name__			=      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




'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


__magic_name__			=      {
    'configuration_convnext': ['CONVNEXT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ConvNextConfig', 'ConvNextOnnxConfig']
}

try:
     if not is_vision_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __magic_name__			=      ['ConvNextFeatureExtractor']
     __magic_name__			=      ['ConvNextImageProcessor']

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __magic_name__			=      [
         'CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
         'ConvNextForImageClassification',
         'ConvNextModel',
         'ConvNextPreTrainedModel',
         'ConvNextBackbone',
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __magic_name__			=      [
         'TFConvNextForImageClassification',
         'TFConvNextModel',
         'TFConvNextPreTrainedModel',
     ]

if TYPE_CHECKING:
     from .configuration_convnext import CONVNEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvNextConfig, ConvNextOnnxConfig

     try:
          if not is_vision_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .feature_extraction_convnext import ConvNextFeatureExtractor
          from .image_processing_convnext import ConvNextImageProcessor

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_convnext import (
              CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
              ConvNextBackbone,
              ConvNextForImageClassification,
              ConvNextModel,
              ConvNextPreTrainedModel,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_convnext import TFConvNextForImageClassification, TFConvNextModel, TFConvNextPreTrainedModel


else:
     import sys

     __magic_name__			=      _LazyModule(__name__, globals()['__file__'], _import_structure)
