






'''simple docstring'''
from math import isclose, sqrt




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   lowercase_	:    str           =     point_y / 4 / point_x
   lowercase_	:    Tuple           =     2 * normal_gradient / (1 + normal_gradient * normal_gradient)
   lowercase_	:    Union[str, Any]           =     (1 - normal_gradient * normal_gradient) / (
       1 + normal_gradient * normal_gradient
   )
   lowercase_	:    Tuple           =     (sa - ca * incoming_gradient) / (ca + sa * incoming_gradient)

   # to find the next point, solve the simultaeneous equations:
   # y^2 + 4x^2 = 100
   # y - b = m * (x - a)
   # ==> A x^2 + B x + C = 0
   lowercase_	:    Union[str, Any]           =     outgoing_gradient**2 + 4
   lowercase_	:    Tuple           =     2 * outgoing_gradient * (point_y - outgoing_gradient * point_x)
   lowercase_	:    Optional[int]           =     (point_y - outgoing_gradient * point_x) ** 2 - 100

   lowercase_	:    Union[str, Any]           =     (
       -linear_term - sqrt(linear_term**2 - 4 * quadratic_term * constant_term							)
   ) / (2 * quadratic_term)
   lowercase_	:    List[str]           =     (
       -linear_term + sqrt(linear_term**2 - 4 * quadratic_term * constant_term							)
   ) / (2 * quadratic_term)

   # two solutions, one of which is our input point
   lowercase_	:    Optional[int]           =     x_minus if isclose(_UpperCamelCase						,		_UpperCamelCase							) else x_plus
   lowercase_	:    List[str]           =     point_y + outgoing_gradient * (next_x - point_x)

   return next_x, next_y, outgoing_gradient




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase = 1.4						,		_UpperCamelCase = -9.6							):


   """simple docstring"""




   lowercase_	:    int           =     0
   lowercase_	:    float           =     first_x_coord
   lowercase_	:    float           =     first_y_coord
   lowercase_	:    float           =     (10.1 - point_y) / (0.0 - point_x)

   while not (-0.01 <= point_x <= 0.01 and point_y > 0):
      lowercase_    ,		lowercase_    ,		lowercase_	:    str           =     next_point(_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							)
      num_reflections += 1

   return num_reflections


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












'''simple docstring'''
import heapq




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase							):


   """simple docstring"""




   lowercase_	:    list[list]           =     []

   # for each node and his adjacency list add them and the rank of the node to queue
   # using heapq module the queue will be filled like a Priority Queue
   # heapq works with a min priority queue, so I used -1*len(v) to build it
   for key, value in graph.items():
      # O(log(n))
      heapq.heappush(_UpperCamelCase						,		[-1 * len(_UpperCamelCase							), (key, value)]							)

   # chosen_vertices = set of chosen vertices
   lowercase_	:    Optional[Any]           =     set()

   # while queue isn't empty and there are still edges
   #   (queue[0][0] is the rank of the node with max rank)
   while queue and queue[0][0] != 0:
      # extract vertex with max rank from queue and add it to chosen_vertices
      lowercase_	:    Any           =     heapq.heappop(_UpperCamelCase							)[1][0]
      chosen_vertices.add(_UpperCamelCase							)

      # Remove all arcs adjacent to argmax
      for elem in queue:
         # if v haven't adjacent node, skip
         if elem[0] == 0:
            continue
         # if argmax is reachable from elem
         # remove argmax from elem's adjacent list and update his rank
         if argmax in elem[1][1]:
            lowercase_	:    str           =     elem[1][1].index(_UpperCamelCase							)
            del elem[1][1][index]
            elem[0] += 1
        # re-order the queue
      heapq.heapify(_UpperCamelCase							)
   return chosen_vertices


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 UpperCamelCase__ =			{0: [1, 3], 1: [0, 3], 2: [0, 3, 4], 3: [0, 1, 2], 4: [2, 3]}
 print(f"""Minimum vertex cover:\n{greedy_min_vertex_cover(graph)}""")




