






'''simple docstring'''







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





def 		_UpperCAmelCase   (							__A							:   Dict						,		__A							:   Optional[int]      ):
				a_		:  Dict											=      [[float('''inf'''      ) for _ in range(__A      )] for _ in range(__A      )]

				for i in range(__A      ):
								for j in range(__A      ):
												a_		:  Tuple											=      graph[i][j]

												# check vertex k against all other vertices (i, j)
				for k in range(__A      ):
								# looping through rows of graph array
								for i in range(__A      ):
												# looping through columns of graph array
												for j in range(__A      ):
																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(__A						,		__A      )
				return dist, v


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

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

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


__lowerCAmelCase       		=      {
    'configuration_git': ['GIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GitConfig', 'GitVisionConfig'],
    'processing_git': ['GitProcessor'],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__lowerCAmelCase       		=      [
		    'GIT_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'GitForCausalLM',
		    'GitModel',
		    'GitPreTrainedModel',
		    'GitVisionModel',
		]

if TYPE_CHECKING:
		from .configuration_git import GIT_PRETRAINED_CONFIG_ARCHIVE_MAP, GitConfig, GitVisionConfig
		from .processing_git import GitProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_git import (
				    GIT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    GitForCausalLM,
				    GitModel,
				    GitPreTrainedModel,
				    GitVisionModel,
				)

else:
		import sys

		__lowerCAmelCase       		=      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




