'''simple docstring'''





def    A			(					_lowercase	,						_lowercase		):
						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			(					_lowercase	,						_lowercase		):
						SCREAMING_SNAKE_CASE							:					Optional[int]           =							[[float('''inf'''		) for _ in range(_lowerCamelCase		)] for _ in range(_lowerCamelCase		)]

						for i in range(_lowerCamelCase		):
												for j in range(_lowerCamelCase		):
																		SCREAMING_SNAKE_CASE							:					Dict           =							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]
																								):
																														SCREAMING_SNAKE_CASE							:					Any           =							dist[i][k] + dist[k][j]

						_print_dist(_lowerCamelCase	,						_lowerCamelCase		)
						return dist, v


if __name__ == "__main__":
					__UpperCamelCase	: Tuple    		=  int(input('Enter number of vertices: '))
					__UpperCamelCase	: Optional[int]    		=  int(input('Enter number of edges: '))

					__UpperCamelCase	: Any    		=  [[float('inf') for i in range(v)] for j in range(v)]

					for i in range(v):
										__UpperCamelCase	: List[str]    		=  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)
										__UpperCamelCase	: str    		=  int(input('Enter source:'))
										__UpperCamelCase	: Dict    		=  int(input('Enter destination:'))
										__UpperCamelCase	: List[str]    		=  float(input('Enter weight:'))
										__UpperCamelCase	: 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 TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__UpperCamelCase	: Tuple    		=  {
    'configuration_ctrl': ['CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP', 'CTRLConfig'],
    'tokenization_ctrl': ['CTRLTokenizer'],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__UpperCamelCase	: Dict    		=  [
					    'CTRL_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'CTRLForSequenceClassification',
					    'CTRLLMHeadModel',
					    'CTRLModel',
					    'CTRLPreTrainedModel',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__UpperCamelCase	: Any    		=  [
					    'TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'TFCTRLForSequenceClassification',
					    'TFCTRLLMHeadModel',
					    'TFCTRLModel',
					    'TFCTRLPreTrainedModel',
					]


if TYPE_CHECKING:
					from .configuration_ctrl import CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRLConfig
					from .tokenization_ctrl import CTRLTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_ctrl import (
										    CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    CTRLForSequenceClassification,
										    CTRLLMHeadModel,
										    CTRLModel,
										    CTRLPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_ctrl import (
										    TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFCTRLForSequenceClassification,
										    TFCTRLLMHeadModel,
										    TFCTRLModel,
										    TFCTRLPreTrainedModel,
										)

else:
					import sys

					__UpperCamelCase	: Optional[Any]    		=  _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





