



def 			A_      (	__a     :				List[str] ,		__a     :				Optional[int]		):

				"""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 			A_      (	__a     :				List[Any] ,		__a     :				str		):

				"""simple docstring"""
				a__				      =		[[float("""inf"""		) for _ in range(snake_case_		)] for _ in range(snake_case_		)]

				for i in range(snake_case_		):
								for j in range(snake_case_		):
												a__				      =		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]
																):
																				a__				      =		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






# coding=utf-8
# Copyright 2020 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import sys

import transformers


UpperCAmelCase							 =					"""3"""

print("""Python version:""", sys.version)
print("""transformers version:""", transformers.__version__)

try:
	import torch

	print("""Torch version:""", torch.__version__)
	print("""Cuda available:""", torch.cuda.is_available())
	print("""Cuda version:""", torch.version.cuda)
	print("""CuDNN version:""", torch.backends.cudnn.version())
	print("""Number of GPUs available:""", torch.cuda.device_count())
	print("""NCCL version:""", torch.cuda.nccl.version())
except ImportError:
	print("""Torch version:""", None)

try:
	import deepspeed

	print("""DeepSpeed version:""", deepspeed.__version__)
except ImportError:
	print("""DeepSpeed version:""", None)

try:
	import tensorflow as tf

	print("""TensorFlow version:""", tf.__version__)
	print("""TF GPUs available:""", bool(tf.config.list_physical_devices("""GPU""")))
	print("""Number of TF GPUs available:""", len(tf.config.list_physical_devices("""GPU""")))
except ImportError:
	print("""TensorFlow version:""", None)

