



from __future__ import annotations

def        a						(      _UpperCAmelCase							:					list[float] ,   _UpperCAmelCase							:					Union[str, Any]						):







		'''simple docstring'''





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

def        a						(      _UpperCAmelCase							:					list[dict[str, int]] ,   _UpperCAmelCase							:					list[float] ,   _UpperCAmelCase							:					int						):







		'''simple docstring'''





		for j in range(_UpperCAmelCase						):
				__UpperCAmelCase							,					__UpperCAmelCase							,					__UpperCAmelCase    :     str													=	(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        a						(      _UpperCAmelCase							:					list[dict[str, int]] ,   _UpperCAmelCase							:					int ,   _UpperCAmelCase							:					int ,   _UpperCAmelCase							:					int						):







		'''simple docstring'''





		__UpperCAmelCase    :     Dict													=	[float('''inf'''						)] * vertex_count
		__UpperCAmelCase    :     List[Any]													=	0.0

		for _ in range(vertex_count - 1						):
				for j in range(_UpperCAmelCase						):
						__UpperCAmelCase							,					__UpperCAmelCase							,					__UpperCAmelCase    :     List[Any]													=	(graph[j][k] for k in ['''src''', '''dst''', '''weight'''])

						if distance[u] != float('''inf'''						) and distance[u] + w < distance[v]:
								__UpperCAmelCase    :     Optional[Any]													=	distance[u] + w

		__UpperCAmelCase    :     int													=	check_negative_cycle(_UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)
		if negative_cycle_exists:
				raise Exception('''Negative cycle found'''						)

		return distance


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				__A   			=int(input("Enter number of vertices: ").strip())
				__A   			=int(input("Enter number of edges: ").strip())

				__A   			=[{} for _ in range(E)]

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

				__A   			=int(input("\nEnter shortest path source:").strip())
				__A   			=bellman_ford(graph, V, E, source)
				print_distance(shortest_distance, 0)










def        a						(      _UpperCAmelCase							:					Any						):







		'''simple docstring'''





		__UpperCAmelCase    :     Any													=	0
		__UpperCAmelCase    :     str													=	len(_UpperCAmelCase						)

		for i in range(n - 1						):
				for j in range(i + 1 ,   _UpperCAmelCase						):
						if arr[i] > arr[j]:
								num_inversions += 1

		return num_inversions

def        a						(      _UpperCAmelCase							:					str						):







		'''simple docstring'''





		if len(_UpperCAmelCase						) <= 1:
				return arr, 0
		__UpperCAmelCase    :     Dict													=	len(_UpperCAmelCase						) // 2
		__UpperCAmelCase    :     Union[str, Any]													=	arr[0:mid]
		__UpperCAmelCase    :     Optional[Any]													=	arr[mid:]

		__UpperCAmelCase							,					__UpperCAmelCase    :     Tuple													=	count_inversions_recursive(_UpperCAmelCase						)
		__UpperCAmelCase							,					__UpperCAmelCase    :     Optional[Any]													=	count_inversions_recursive(_UpperCAmelCase						)
		__UpperCAmelCase							,					__UpperCAmelCase    :     int													=	_count_cross_inversions(_UpperCAmelCase ,   _UpperCAmelCase						)

		__UpperCAmelCase    :     List[str]													=	inversion_p + inversions_q + cross_inversions
		return c, num_inversions

def        a						(      _UpperCAmelCase							:					List[str] ,   _UpperCAmelCase							:					Any						):







		'''simple docstring'''





		__UpperCAmelCase    :     List[Any]													=	[]
		__UpperCAmelCase    :     Any													=	0
		while i < len(_UpperCAmelCase						) and j < len(_UpperCAmelCase						):
				if p[i] > q[j]:
						# if P[1] > Q[j], then P[k] > Q[k] for all  i < k <= len(P)
						# These are all inversions. The claim emerges from the
						# property that P is sorted.
						num_inversion += len(_UpperCAmelCase						) - i
						r.append(q[j]						)
						j += 1
				else:
						r.append(p[i]						)
						i += 1

		if i < len(_UpperCAmelCase						):
				r.extend(p[i:]						)
		else:
				r.extend(q[j:]						)

		return r, num_inversion

def        a						(      ):







		'''simple docstring'''





		__UpperCAmelCase    :     Optional[Any]													=	[10, 2, 1, 5, 5, 2, 11]

		# this arr has 8 inversions:
		# (10, 2), (10, 1), (10, 5), (10, 5), (10, 2), (2, 1), (5, 2), (5, 2)

		__UpperCAmelCase    :     List[str]													=	count_inversions_bf(_UpperCAmelCase						)
		__UpperCAmelCase							,					__UpperCAmelCase    :     Tuple													=	count_inversions_recursive(_UpperCAmelCase						)

		assert num_inversions_bf == num_inversions_recursive == 8

		print('''number of inversions = ''' ,   _UpperCAmelCase						)

		# testing an array with zero inversion (a sorted arr_1)

		arr_a.sort()
		__UpperCAmelCase    :     Any													=	count_inversions_bf(_UpperCAmelCase						)
		__UpperCAmelCase							,					__UpperCAmelCase    :     int													=	count_inversions_recursive(_UpperCAmelCase						)

		assert num_inversions_bf == num_inversions_recursive == 0
		print('''number of inversions = ''' ,   _UpperCAmelCase						)

		# an empty list should also have zero inversions
		__UpperCAmelCase    :     Tuple													=	[]
		__UpperCAmelCase    :     Union[str, Any]													=	count_inversions_bf(_UpperCAmelCase						)
		__UpperCAmelCase							,					__UpperCAmelCase    :     int													=	count_inversions_recursive(_UpperCAmelCase						)

		assert num_inversions_bf == num_inversions_recursive == 0
		print('''number of inversions = ''' ,   _UpperCAmelCase						)


if __name__ == "__main__":
				main()





