
'''simple docstring'''
def   UpperCamelCase_       (		__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE    ):
    """simple docstring"""






    print("\nVertex Distance"    )
    for i in range(_A    ):
        if dist[i] != float("inf"    ):
            print(_A,						"\t",						int(dist[i]    ),						end="\t"    )
        else:
            print(_A,						"\t",						"INF",						end="\t"    )
        print()

def   UpperCamelCase_       (		__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE    ):
    """simple docstring"""






    snake_case_	:      List[Any]            =  float("inf"    )
    snake_case_	:      Optional[Any]            =  -1
    for i in range(_A    ):
        if (not vset[i]) and mdist[i] < min_val:
            snake_case_	:      Optional[int]            =  i
            snake_case_	:      str            =  mdist[i]
    return min_ind

def   UpperCamelCase_       (		__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE    ):
    """simple docstring"""






    snake_case_	:      str            =  [float("inf"    ) for _ in range(_A    )]
    snake_case_	:      Optional[Any]            =  [False for _ in range(_A    )]
    snake_case_	:      Tuple            =  0.0

    for _ in range(v - 1    ):
        snake_case_	:      Optional[Any]            =  min_dist(_A,						_A,						_A    )
        snake_case_	:      Tuple            =  True

        for i in range(_A    ):
            if (
                (not vset[i])
                and graph[u][i] != float("inf"    )
                and mdist[u] + graph[u][i] < mdist[i]
            ):
                snake_case_	:      List[str]            =  mdist[u] + graph[u][i]

    print_dist(_A,						_A    )


if __name__ == "__main__":
  a_     =  int(input("Enter number of vertices: ").strip())
  a_     =  int(input("Enter number of edges: ").strip())

  a_     =  [[float("inf") for i in range(V)] for j in range(V)]

  for i in range(V):
    a_     =  0.0

  for i in range(E):
    print("\nEdge ", i + 1)
    a_     =  int(input("Enter source:").strip())
    a_     =  int(input("Enter destination:").strip())
    a_     =  float(input("Enter weight:").strip())
    a_     =  weight

  a_     =  int(input("\nEnter shortest path source:").strip())
  dijkstra(graph, V, gsrc)






'''simple docstring'''
from __future__ import annotations

from collections.abc import Callable

def   UpperCamelCase_       (		__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE = 1_0_0,						):
    """simple docstring"""






    snake_case_	:      Optional[Any]            =  x_start
    snake_case_	:      str            =  fnc(__SCREAMING_SNAKE_CASE    )
    snake_case_	:      List[str]            =  0.0

    for _ in range(__SCREAMING_SNAKE_CASE    ):
        # Approximates small segments of curve as linear and solve
        # for trapezoidal area
        snake_case_	:      List[str]            =  (x_end - x_start) / steps + xa
        snake_case_	:      Optional[int]            =  fnc(__SCREAMING_SNAKE_CASE    )
        area += abs(fxa + fxa    ) * (xa - xa) / 2

        # Increment step
        snake_case_	:      List[Any]            =  xa
        snake_case_	:      Optional[Any]            =  fxa
    return area


if __name__ == "__main__":

  def   UpperCamelCase_       (		__SCREAMING_SNAKE_CASE    ):
      """simple docstring"""






      return x**3

  print("f(x) = x^3")
  print("The area between the curve, x = -10, x = 10 and the x axis is:")
  a_     =  10
  while i <= 10_0000:
    a_     =  trapezoidal_area(f, -5, 5, i)
    print(f"""with {i} steps: {area}""")
    i *= 10




