


def 	_lowerCAmelCase					( UpperCamelCase__:  Optional[Any]				,       UpperCamelCase__:  str    )			-> Any:





	"""simple docstring"""







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





def 	_lowerCAmelCase					( UpperCamelCase__:  Optional[int]				,       UpperCamelCase__:  int    )			-> int:





	"""simple docstring"""







	A             =					[[float("""inf"""    ) for _ in range(UpperCamelCase__    )] for _ in range(UpperCamelCase__    )]

	for i in range(UpperCamelCase__    ):
		for j in range(UpperCamelCase__    ):
			A             =					graph[i][j]

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


if __name__ == "__main__":
				_lowercase							:   List[Any]						=						int(input("Enter number of vertices: "))
				_lowercase							:   Any						=						int(input("Enter number of edges: "))

				_lowercase							:   List[Any]						=						[[float("inf") for i in range(v)] for j in range(v)]

				for i in range(v):
								_lowercase							:   Tuple						=						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)
								_lowercase							:   Any						=						int(input("Enter source:"))
								_lowercase							:   int						=						int(input("Enter destination:"))
								_lowercase							:   str						=						float(input("Enter weight:"))
								_lowercase							:   List[Any]						=						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







def 	_lowerCAmelCase					( UpperCamelCase__:  Union[str, Any]    )			-> Dict:





	"""simple docstring"""







	return [
	    {
	        0: [1, 2],
	        1: [0, 2],
	        2: [0, 1, 3, 5],
	        3: [2, 4],
	        4: [3],
	        5: [2, 6, 8],
	        6: [5, 7],
	        7: [6, 8],
	        8: [5, 7],
	    },
	    {
	        0: [6],
	        1: [9],
	        2: [4, 5],
	        3: [4],
	        4: [2, 3],
	        5: [2],
	        6: [0, 7],
	        7: [6],
	        8: [],
	        9: [1],
	    },
	    {
	        0: [4],
	        1: [6],
	        2: [],
	        3: [5, 6, 7],
	        4: [0, 6],
	        5: [3, 8, 9],
	        6: [1, 3, 4, 7],
	        7: [3, 6, 8, 9],
	        8: [5, 7],
	        9: [5, 7],
	    },
	    {
	        0: [1, 3],
	        1: [0, 2, 4],
	        2: [1, 3, 4],
	        3: [0, 2, 4],
	        4: [1, 2, 3],
	    },
	][index]





def 	_lowerCAmelCase					( UpperCamelCase__:  dict[int, list[int]]    )			-> list[tuple[int, int]]:





	"""simple docstring"""







	A             =					0
	A             =					len(UpperCamelCase__    )  # No of vertices in graph
	A             =					[0] * n
	A             =					[False] * n

	def dfs(UpperCamelCase__:  Union[str, Any]				,       UpperCamelCase__:  str				,       UpperCamelCase__:  Union[str, Any]				,       UpperCamelCase__:  Any    ):
		A             =					True
		A             =					id_
		id_ += 1
		for to in graph[at]:
			if to == parent:
				pass
			elif not visited[to]:
				dfs(UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       id_    )
				A             =					min(low[at]				,       low[to]    )
				if id_ <= low[to]:
					bridges.append((at, to) if at < to else (to, at)    )
			else:
				# This edge is a back edge and cannot be a bridge
				A             =					min(low[at]				,       low[to]    )

	A             =					[]
	for i in range(UpperCamelCase__    ):
		if not visited[i]:
			dfs(UpperCamelCase__				,       -1				,       UpperCamelCase__				,       id_    )
	return bridges


if __name__ == "__main__":
				import doctest

				doctest.testmod()



