






def 	__lowerCamelCase      (		snake_case__	,snake_case__		)							->  Union[str, Any]:






						"""simple docstring"""





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

def 	__lowerCamelCase      (		snake_case__	,snake_case__		)							->  int:






						"""simple docstring"""





						_SCREAMING_SNAKE_CASE     				=  [[float("""inf"""		) for _ in range(snake_case__		)] for _ in range(snake_case__		)]

						for i in range(snake_case__		):
												for j in range(snake_case__		):
																		_SCREAMING_SNAKE_CASE     				=  graph[i][j]

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

						_print_dist(snake_case__	,snake_case__		)
						return dist, v


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

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

		for i in range(v):
				UpperCamelCase			    =     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			    =     int(input('''Enter source:'''))
				UpperCamelCase			    =     int(input('''Enter destination:'''))
				UpperCamelCase			    =     float(input('''Enter weight:'''))
				UpperCamelCase			    =     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 collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


UpperCamelCase			    =     logging.get_logger(__name__)

UpperCamelCase			    =     {
    '''google/mobilenet_v1_1.0_224''': '''https://huggingface.co/google/mobilenet_v1_1.0_224/resolve/main/config.json''',
    '''google/mobilenet_v1_0.75_192''': '''https://huggingface.co/google/mobilenet_v1_0.75_192/resolve/main/config.json''',
    # See all MobileNetV1 models at https://huggingface.co/models?filter=mobilenet_v1
}



class 				__UpperCAmelCase		(_UpperCAmelCase   ):
			__snake_case    :				Any									=							"mobilenet_v1"







			def __init__(     self:  List[str]				,     UpperCAmelCase_:  List[Any]=3				,     UpperCAmelCase_:  List[str]=224				,     UpperCAmelCase_:  Optional[Any]=1.0				,     UpperCAmelCase_:  Dict=8				,     UpperCAmelCase_:  List[str]="relu6"				,     UpperCAmelCase_:  List[Any]=True				,     UpperCAmelCase_:  Dict=0.9_99				,     UpperCAmelCase_:  Union[str, Any]=0.02				,     UpperCAmelCase_:  Tuple=0.0_01				,     **UpperCAmelCase_:  List[str]				,     ):







									'''simple docstring'''




									super().__init__(**UpperCAmelCase_					)

									if depth_multiplier <= 0:
															raise ValueError("""depth_multiplier must be greater than zero."""					)

									_SCREAMING_SNAKE_CASE     				=  num_channels
									_SCREAMING_SNAKE_CASE     				=  image_size
									_SCREAMING_SNAKE_CASE     				=  depth_multiplier
									_SCREAMING_SNAKE_CASE     				=  min_depth
									_SCREAMING_SNAKE_CASE     				=  hidden_act
									_SCREAMING_SNAKE_CASE     				=  tf_padding
									_SCREAMING_SNAKE_CASE     				=  classifier_dropout_prob
									_SCREAMING_SNAKE_CASE     				=  initializer_range
									_SCREAMING_SNAKE_CASE     				=  layer_norm_eps



class 				__UpperCAmelCase		(_UpperCAmelCase   ):
			__snake_case    :				List[Any]									=							version.parse("1.11"   )







			@property
			def 							UpperCamelCase				(     self:  Tuple					):







									'''simple docstring'''




									return OrderedDict([("""pixel_values""", {0: """batch"""})]					)







			@property
			def 							UpperCamelCase				(     self:  Dict					):







									'''simple docstring'''




									if self.task == "image-classification":
															return OrderedDict([("""logits""", {0: """batch"""})]					)
									else:
															return OrderedDict([("""last_hidden_state""", {0: """batch"""}), ("""pooler_output""", {0: """batch"""})]					)







			@property
			def 							UpperCamelCase				(     self:  int					):







									'''simple docstring'''




									return 1E-4

