


import math



class 				A       :
					'''simple docstring'''






					def __init__(self       :		Tuple ,   _UpperCAmelCase       :		Union[str, Any]=0						)		->  Union[str, Any]:  # a graph with Node 0,1,...,N-1




							"""simple docstring"""


							lowercase__	     =						n
							lowercase__	     =						[
							    [math.inf for j in range(0 ,   _UpperCAmelCase						)] for i in range(0 ,   _UpperCAmelCase						)
							]  # adjacency matrix for weight
							lowercase__	     =						[
							    [math.inf for j in range(0 ,   _UpperCAmelCase						)] for i in range(0 ,   _UpperCAmelCase						)
							]  # dp[i][j] stores minimum distance from i to j

					def     lowerCamelCase__	(self       :		Any ,   _UpperCAmelCase       :		Any ,   _UpperCAmelCase       :		List[Any] ,   _UpperCAmelCase       :		Optional[Any]						)		->  str:




							"""simple docstring"""


							lowercase__	     =						w

					def     lowerCamelCase__	(self       :		str						)		->  Optional[Any]:




							"""simple docstring"""


							for k in range(0 ,   self.n						):
									for i in range(0 ,   self.n						):
											for j in range(0 ,   self.n						):
													lowercase__	     =						min(self.dp[i][j] ,   self.dp[i][k] + self.dp[k][j]						)


					def     lowerCamelCase__	(self       :		Union[str, Any] ,   _UpperCAmelCase       :		List[str] ,   _UpperCAmelCase       :		List[Any]						)		->  str:




							"""simple docstring"""


							return self.dp[u][v]


if __name__ == "__main__":
	A			:						Dict        =  Graph(5)
	graph.add_edge(0, 2, 9)
	graph.add_edge(0, 4, 1_0)
	graph.add_edge(1, 3, 5)
	graph.add_edge(2, 3, 7)
	graph.add_edge(3, 0, 1_0)
	graph.add_edge(3, 1, 2)
	graph.add_edge(3, 2, 1)
	graph.add_edge(3, 4, 6)
	graph.add_edge(4, 1, 3)
	graph.add_edge(4, 2, 4)
	graph.add_edge(4, 3, 9)
	graph.floyd_warshall()
	graph.show_min(1, 4)
	graph.show_min(0, 3)









'''simple docstring'''

def 				snake_case       (  a_				:			str     , a_				:			Optional[int]						)							->					Any:





      """simple docstring"""

      UpperCamelCase_					: Tuple            =				(boundary[1] - boundary[0]) / steps
      UpperCamelCase_					: Dict            =				boundary[0]
      UpperCamelCase_					: Any            =				boundary[1]
      UpperCamelCase_					: Union[str, Any]            =				make_points(a_     , a_     , a_						)
      UpperCamelCase_					: Any            =				0.0
      y += (h / 2.0) * f(a_						)
      for i in x_i:
            # print(i)
            y += h * f(a_						)
      y += (h / 2.0) * f(a_						)
      return y



def 				snake_case       (  a_				:			Tuple     , a_				:			Any     , a_				:			Tuple						)							->					Tuple:





      """simple docstring"""

      UpperCamelCase_					: Optional[int]            =				a + h
      while x < (b - h):
            yield x
            UpperCamelCase_					: List[str]            =				x + h



def 				snake_case       (  a_				:			List[str]						)							->					Tuple:  # enter your function here





      """simple docstring"""

      UpperCamelCase_					: int            =				(x - 0) * (x - 0)
      return y



def 				snake_case       (  )							->					Dict:





      """simple docstring"""

      UpperCamelCase_					: Optional[Any]            =				0.0  # Lower bound of integration
      UpperCamelCase_					: Optional[int]            =				1.0  # Upper bound of integration
      UpperCamelCase_					: Optional[Any]            =				10.0  # define number of steps or resolution
      UpperCamelCase_					: Optional[Any]            =				[a, b]  # define boundary of integration
      UpperCamelCase_					: Any            =				method_a(a_     , a_						)
      print(f"y = {y}"						)


if __name__ == "__main__":
      main()






