






import datasets


SCREAMING_SNAKE_CASE__   :      Any				=		"""\
@InProceedings{conneau2018xnli,
  author = \"Conneau, Alexis
                 and Rinott, Ruty
                 and Lample, Guillaume
                 and Williams, Adina
                 and Bowman, Samuel R.
                 and Schwenk, Holger
                 and Stoyanov, Veselin\",
  title = \"XNLI: Evaluating Cross-lingual Sentence Representations\",
  booktitle = \"Proceedings of the 2018 Conference on Empirical Methods
               in Natural Language Processing\",
  year = \"2018\",
  publisher = \"Association for Computational Linguistics\",
  location = \"Brussels, Belgium\",
}
"""

SCREAMING_SNAKE_CASE__   :      Optional[Any]				=		"""\
XNLI is a subset of a few thousand examples from MNLI which has been translated
into a 14 different languages (some low-ish resource). As with MNLI, the goal is
to predict textual entailment (does sentence A imply/contradict/neither sentence
B) and is a classification task (given two sentences, predict one of three
labels).
"""

SCREAMING_SNAKE_CASE__   :      Optional[int]				=		"""
Computes XNLI score which is just simple accuracy.
Args:
    predictions: Predicted labels.
    references: Ground truth labels.
Returns:
    'accuracy': accuracy
Examples:

    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> xnli_metric = datasets.load_metric(\"xnli\")
    >>> results = xnli_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}
"""

def   __lowercase       (			snake_case,	snake_case			):







				"""simple docstring"""






				return (preds == labels).mean()

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION      ,					_KWARGS_DESCRIPTION			)
class     lowerCamelCase_					(   datasets.Metric			):







				def       A						(    self  ):
								"""simple docstring"""
								return datasets.MetricInfo(
								    description=_DESCRIPTION							,       citation=_CITATION							,       inputs_description=_KWARGS_DESCRIPTION							,       features=datasets.Features(
								        {
								            '''predictions''': datasets.Value('''int64''' if self.config_name != '''sts-b''' else '''float32'''  ),
								            '''references''': datasets.Value('''int64''' if self.config_name != '''sts-b''' else '''float32'''  ),
								        }  )							,       codebase_urls=[]							,       reference_urls=[]							,       format='''numpy'''							,       )







				def       A						(    self							,       __lowerCAmelCase							,       __lowerCAmelCase  ):
								"""simple docstring"""
								return {"accuracy": simple_accuracy(__lowerCAmelCase							,       __lowerCAmelCase  )}














from __future__ import annotations

def   __lowercase       (			snake_case,	snake_case			):







				"""simple docstring"""






				print(f'''Vertex\tShortest Distance from vertex {src}'''			)
				for i, d in enumerate(snake_case			):
								print(f'''{i}\t\t{d}'''			)

def   __lowercase       (			snake_case,	snake_case,	snake_case			):







				"""simple docstring"""






				for j in range(snake_case			):
								__magic_name__  ,					__magic_name__  ,					__magic_name__		:Tuple   =   (graph[j][k] for k in ['''src''', '''dst''', '''weight'''])
								if distance[u] != float('''inf'''			) and distance[u] + w < distance[v]:
												return True
				return False

def   __lowercase       (			snake_case,	snake_case,	snake_case,	snake_case			):







				"""simple docstring"""






				__magic_name__		:List[Any]   =   [float('''inf'''			)] * vertex_count
				__magic_name__		:Tuple   =   0.0

				for _ in range(vertex_count - 1			):
								for j in range(snake_case			):
												__magic_name__  ,					__magic_name__  ,					__magic_name__		:Dict   =   (graph[j][k] for k in ['''src''', '''dst''', '''weight'''])

												if distance[u] != float('''inf'''			) and distance[u] + w < distance[v]:
																__magic_name__		:Tuple   =   distance[u] + w

				__magic_name__		:Tuple   =   check_negative_cycle(snake_case,	snake_case,	snake_case			)
				if negative_cycle_exists:
								raise Exception('''Negative cycle found'''			)

				return distance


if __name__ == "__main__":
					import doctest

					doctest.testmod()

					SCREAMING_SNAKE_CASE__   :      Tuple				=		int(input("""Enter number of vertices: """).strip())
					SCREAMING_SNAKE_CASE__   :      Any				=		int(input("""Enter number of edges: """).strip())

					SCREAMING_SNAKE_CASE__   :      list[dict[str, int]]				=		[{} for _ in range(E)]

					for i in range(E):
										print("""Edge """, i + 1)
										SCREAMING_SNAKE_CASE__				,       SCREAMING_SNAKE_CASE__				,       SCREAMING_SNAKE_CASE__   :      Dict				=		(
										    int(x)
										    for x in input("""Enter source, destination, weight: """).strip().split(""" """)
										)
										SCREAMING_SNAKE_CASE__   :      Dict				=		{"""src""": src, """dst""": dest, """weight""": weight}

					SCREAMING_SNAKE_CASE__   :      List[Any]				=		int(input("""\nEnter shortest path source:""").strip())
					SCREAMING_SNAKE_CASE__   :      List[str]				=		bellman_ford(graph, V, E, source)
					print_distance(shortest_distance, 0)






