

"""simple docstring"""
def 			__UpperCamelCase	(		snake_case__   ,   snake_case__					):
	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 			__UpperCamelCase	(		snake_case__   ,   snake_case__					):
	A_		:						Optional[Any]	    =   [[float("""inf"""					) for _ in range(__UpperCamelCase					)] for _ in range(__UpperCamelCase					)]

	for i in range(__UpperCamelCase					):
		for j in range(__UpperCamelCase					):
			A_		:						List[Any]	    =   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_		:						Optional[Any]	    =   dist[i][k] + dist[k][j]

	_print_dist(__UpperCamelCase   ,   __UpperCamelCase					)
	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_luke": ["LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP", "LukeConfig"],
    "tokenization_luke": ["LukeTokenizer"],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							_lowerCAmelCase         =							[
							    "LUKE_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "LukeForEntityClassification",
							    "LukeForEntityPairClassification",
							    "LukeForEntitySpanClassification",
							    "LukeForMultipleChoice",
							    "LukeForQuestionAnswering",
							    "LukeForSequenceClassification",
							    "LukeForTokenClassification",
							    "LukeForMaskedLM",
							    "LukeModel",
							    "LukePreTrainedModel",
							]


if TYPE_CHECKING:
							from .configuration_luke import LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP, LukeConfig
							from .tokenization_luke import LukeTokenizer

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_luke import (
														    LUKE_PRETRAINED_MODEL_ARCHIVE_LIST,
														    LukeForEntityClassification,
														    LukeForEntityPairClassification,
														    LukeForEntitySpanClassification,
														    LukeForMaskedLM,
														    LukeForMultipleChoice,
														    LukeForQuestionAnswering,
														    LukeForSequenceClassification,
														    LukeForTokenClassification,
														    LukeModel,
														    LukePreTrainedModel,
														)

else:
							import sys

							_lowerCAmelCase         =							_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

