





import math



class  A__       :





						def __init__(			self	,							A_=0       ):  # a graph with Node 0,1,...,N-1
							'''simple docstring'''




							UpperCamelCase     : Optional[int]	     =       n
							UpperCamelCase     : int	     =       [
							    [math.inf for j in range(0	,							A_       )] for i in range(0	,							A_       )
							]  # adjacency matrix for weight
							UpperCamelCase     : int	     =       [
							    [math.inf for j in range(0	,							A_       )] for i in range(0	,							A_       )
							]  # dp[i][j] stores minimum distance from i to j





						def 	__UpperCamelCase(			self	,							A_	,							A_	,							A_       ):
							'''simple docstring'''




							UpperCamelCase     : int	     =       w





						def 	__UpperCamelCase(			self       ):
							'''simple docstring'''




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





						def 	__UpperCamelCase(			self	,							A_	,							A_       ):
							'''simple docstring'''




							return self.dp[u][v]


if __name__ == "__main__":
				__lowerCamelCase	:					Union[str, Any]			  =					Graph(5)
				graph.add_edge(0, 2, 9)
				graph.add_edge(0, 4, 10)
				graph.add_edge(1, 3, 5)
				graph.add_edge(2, 3, 7)
				graph.add_edge(3, 0, 10)
				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)







from __future__ import annotations



def 		A_    (					_lowerCAmelCase							,       _lowerCAmelCase					)						->			list[str]:
 if partitions <= 0:
  raise ValueError("partitions must be a positive number!"					)
 if partitions > number_of_bytes:
  raise ValueError("partitions can not > number_of_bytes!"					)
 UpperCamelCase     : str	     =       number_of_bytes // partitions
 UpperCamelCase     : List[Any]	     =       []
 for i in range(_lowerCAmelCase					):
  UpperCamelCase     : Optional[Any]	     =       i * bytes_per_partition + 1
  UpperCamelCase     : Any	     =       (
      number_of_bytes if i == partitions - 1 else (i + 1) * bytes_per_partition
  )
  allocation_list.append(F"""{start_bytes}-{end_bytes}"""					)
 return allocation_list


if __name__ == "__main__":
    import doctest

    doctest.testmod()
