


def     __lowerCamelCase						(			UpperCAmelCase_						:		List[str]			,  UpperCAmelCase_						:		List[str]						):




      """simple docstring"""





      print('''\nThe shortest path matrix using Floyd Warshall algorithm\n'''						)
      for i in range(UpperCAmelCase_						):
            for j in range(UpperCAmelCase_						):
                  if dist[i][j] != float('''inf'''						):
                        print(int(dist[i][j]						)			,  end='''\t'''						)
                  else:
                        print('''INF'''			,  end='''\t'''						)
            print()
def     __lowerCamelCase						(			UpperCAmelCase_						:		Any			,  UpperCAmelCase_						:		List[Any]						):




      """simple docstring"""





      a						:str										=	[[float('''inf'''						) for _ in range(UpperCAmelCase_						)] for _ in range(UpperCAmelCase_						)]

      for i in range(UpperCAmelCase_						):
            for j in range(UpperCAmelCase_						):
                  a						:Dict										=	graph[i][j]

                  # check vertex k against all other vertices (i, j)
      for k in range(UpperCAmelCase_						):
            # looping through rows of graph array
            for i in range(UpperCAmelCase_						):
                  # looping through columns of graph array
                  for j in range(UpperCAmelCase_						):
                        if (
                            dist[i][k] != float('''inf'''						)
                            and dist[k][j] != float('''inf'''						)
                            and dist[i][k] + dist[k][j] < dist[i][j]
                        ):
                              a						:int										=	dist[i][k] + dist[k][j]

      _print_dist(UpperCAmelCase_			,  UpperCAmelCase_						)
      return dist, v


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

     snake_case    :   Tuple	    = [[float('''inf''') for i in range(v)] for j in range(v)]

     for i in range(v):
          snake_case    :   List[Any]	    = 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)
          snake_case    :   Optional[int]	    = int(input('''Enter source:'''))
          snake_case    :   Any	    = int(input('''Enter destination:'''))
          snake_case    :   List[Any]	    = float(input('''Enter weight:'''))
          snake_case    :   Any	    = 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 ...utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_torch_available,
    is_transformers_available,
)


try:
     if not (is_transformers_available() and is_torch_available()):
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
     from .multicontrolnet import MultiControlNetModel
     from .pipeline_controlnet import StableDiffusionControlNetPipeline
     from .pipeline_controlnet_imgaimg import StableDiffusionControlNetImgaImgPipeline
     from .pipeline_controlnet_inpaint import StableDiffusionControlNetInpaintPipeline


if is_transformers_available() and is_flax_available():
     from .pipeline_flax_controlnet import FlaxStableDiffusionControlNetPipeline





