
'''simple docstring'''






def 		A_       (	_lowerCAmelCase   :    Optional[int]				,	_lowerCAmelCase   :    Optional[int]							):



      """simple docstring"""




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







def 		A_       (	_lowerCAmelCase   :    Dict				,	_lowerCAmelCase   :    str							):



      """simple docstring"""




      _lowerCamelCase				:   Union[str, Any]								=   [[float("inf"							) for _ in range(lowerCamelCase__							)] for _ in range(lowerCamelCase__							)]

      for i in range(lowerCamelCase__							):
            for j in range(lowerCamelCase__							):
                  _lowerCamelCase				:   Union[str, Any]								=   graph[i][j]

                  # check vertex k against all other vertices (i, j)
      for k in range(lowerCamelCase__							):
            # looping through rows of graph array
            for i in range(lowerCamelCase__							):
                  # looping through columns of graph array
                  for j in range(lowerCamelCase__							):
                        if (
                            dist[i][k] != float("inf"							)
                            and dist[k][j] != float("inf"							)
                            and dist[i][k] + dist[k][j] < dist[i][j]
                        ):
                              _lowerCamelCase				:   Dict								=   dist[i][k] + dist[k][j]

      _print_dist(lowerCamelCase__				,	lowerCamelCase__							)
      return dist, v


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

 UpperCAmelCase_       :   Union[str, Any]   =       [[float('inf') for i in range(v)] for j in range(v)]

 for i in range(v):
  UpperCAmelCase_       :   Optional[int]   =       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)
  UpperCAmelCase_       :   Dict   =       int(input('Enter source:'))
  UpperCAmelCase_       :   str   =       int(input('Enter destination:'))
  UpperCAmelCase_       :   str   =       float(input('Enter weight:'))
  UpperCAmelCase_       :   Optional[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


'''simple docstring'''






import math







def 		A_       (	_lowerCAmelCase   :    int							):



      """simple docstring"""




      _lowerCamelCase				:   Optional[int]								=   math.loga(math.sqrt(4 * positive_integer + 1							) / 2 + 1 / 2							)

      return exponent == int(_lowerCAmelCase							)







def 		A_       (	_lowerCAmelCase   :    float = 1 / 12345							):



      """simple docstring"""




      _lowerCamelCase				:   Optional[int]								=   0
      _lowerCamelCase				:   int								=   0

      _lowerCamelCase				:   List[str]								=   3
      while True:
            _lowerCamelCase				:   List[Any]								=   (integer**2 - 1) / 4
            # if candidate is an integer, then there is a partition for k
            if partition_candidate == int(_lowerCAmelCase							):
                  _lowerCamelCase				:   Any								=   int(_lowerCAmelCase							)
                  total_partitions += 1
                  if check_partition_perfect(_lowerCAmelCase							):
                        perfect_partitions += 1
            if perfect_partitions > 0:
                  if perfect_partitions / total_partitions < max_proportion:
                        return int(_lowerCAmelCase							)
            integer += 1


if __name__ == "__main__":
 print(f'''{solution() = }''')