Problem:
White Bird Angry Birds is  a mobile game  of a big craze all over the world.
You were convinced that it was a waste of time to play the game, so you decided to  create an automatic solver.   You are describing a routine that optimizes the white bird's strategy to defeat a pig (enemy) by hitting an egg bomb.
The white bird  follows a parabolic trajectory  from the initial position,
and it can vertically drop egg bombs on the way. In order to make it easy to solve,  the following conditions hold for the stages.  N obstacles are put on the stage.  Each obstacle is a rectangle whose sides are parallel to the coordinate axes.  The pig is put on the point (X, Y) .  You can launch the white bird  in any direction at an initial velocity V from the origin.  If the white bird collides with an obstacle, it becomes  unable to drop egg bombs.  If the egg bomb collides with an obstacle, the egg bomb is vanished.  The acceleration of gravity is 9.8 {\rm m/s^2} .
Gravity exerts a force  on the objects in the decreasing direction of y -coordinate. Input A dataset follows the format shown below:  N  V  X  Y  L_1  B_1  R_1  T_1  ...  L_N  B_N  R_N  T_N  All inputs are integer.  N : the number of obstacles  V : the initial speed of the white bird  X , Y : the position of the pig  ( 0 \leq N \leq 50 , 0 \leq V \leq 50 , 0 \leq X, Y \leq 300 , X \neq 0 ) for 1 \leq i \leq N,   L_i : the x-coordinate of the left side of the i -th obstacle  B_i : the y-coordinate of the bottom side of the i -th obstacle  R_i : the x-coordinate of the right side of the i -th obstacle  T_i : the y-coordinate of the top side of the i -th obstacle  ( 0 \leq L_i, B_i, R_i, T_i \leq 300 ) It is guaranteed that the answer remains unaffected  by a change of L_i , B_i , R_i and T_i in 10^{-6} . Output Yes/No  You should answer whether the white bird can drop an egg bomb toward the pig. Sample Input 1 0 7 3 1 Output for the Sample Input 1 Yes Sample Input 2 1 7 3 1
1 1 2 2 Output for the Sample Input 2 No Sample Input 3 1 7 2 2
0 1 1 2 Output for the Sample Input 3 No

Solution (Python):
import math

g = 9.8
ESP = 1e-6


def calc(vy, t):
    return vy * t - g * t * t / 2


def cmp(lb, ub, a):
    if a < lb + ESP:
        return -1
    elif ub - ESP < a:
        return 1
    else:
        return 0


def check(qx, qy):
    a = (g * g) / 4
    b = g * qy - V * V
    c = qx * qx + qy * qy
    D = b * b - 4 * a * c

    if D < 0 and -ESP < D:
        D = 0

    if D < 0:
        return False

    for d in range(-1, 2, 2):
        t2 = (-b + d * math.sqrt(D)) / (2 * a)
        if t2 <= 0:
            continue

        t = math.sqrt(t2)
        vx = qx / t
        vy = (qy + g * t * t / 2) / t

        yt = calc(vy, X / vx)
        if yt < Y - ESP:
            continue
        ok = True

        for i in range(0, N):
            if L[i] >= X:
                continue

            if R[i] == X and Y <= T[i] and B[i] <= yt:
                ok = False

            yL = cmp(B[i], T[i], calc(vy, L[i] / vx))
            yR = cmp(B[i], T[i], calc(vy, R[i] / vx))

            xH = cmp(L[i], R[i], vx * (vy / g))
            yH = cmp(B[i], T[i], calc(vy, vy / g))
            if xH == 0 and yH >= 0 and yL < 0:
                ok = False
            if yL * yR <= 0:
                ok = False
        if ok:
            return True
    return False


if __name__ == '__main__':
    N, V, X, Y = list(map(int, input().split()))
    L = []
    B = []
    R = []
    T = []
    for i in range(N):
        tmp_L, tmp_B, tmp_R, tmp_T = list(map(int, input().split()))
        L.append(tmp_L)
        B.append(tmp_B)
        R.append(tmp_R)
        T.append(tmp_T)

    for i in range(0, N):
        R[i] = min(R[i], X)

    ok = check(X, Y)
    for i in range(0, N):
        if L[i] == 0 and T[i] != 0:
            pass
        else:
            ok |= check(L[i], T[i])

        if R[i] == 0 and T[i] != 0:
            pass
        else:
            ok |= check(R[i], T[i])

    print("Yes" if ok else 'No')

Solution (Python):
def calc(vy,t):
     return vy*t - g/2*t*t

def cmp(lb,ub,x):
     if x < lb + eps:
          return -1
     elif x > ub - eps:
          return 1
     return 0

def check(qx,qy):
     if qx == 0:
          return 0
     a = g*g/4
     b = qy*g-V*V
     c = qx*qx+qy*qy
     D = b*b-4*a*c
     if D < -eps:
          return 0
     if -eps<=D<0:
          D = 0
     for d in (-1,1):
          tt = (-b+d*D**.5)/(2*a)
          if tt <= 0:
               continue
          t = tt**.5
          vx = qx/t
          vy = qy/t+g*t/2
          if calc(vy,X/vx) < Y - eps:
               return 0
          for L,B,R,T in obstacles:
               l = cmp(B,T,calc(vy,L/vx))
               r = cmp(B,T,calc(vy,R/vx))
               xh = cmp(L,R,vx*(vy/g))
               yh = cmp(B,T,calc(vy,vy/g))
               if l*r <= 0 or not xh and yh*l <= 0:
                    break
          else:
               return 1
     return 0

g = 9.8
eps = 1e-10
N,V,X,Y = map(int,input().split())
obstacles = []
for i in range(N):
     L,B,R,T = map(int,input().split())
     if L < X:
          obstacles.append((L,B,min(R,X),T))

if check(X,Y):
     print('Yes')
     exit()
for L,B,R,T in obstacles:
     if not L or not R:
          continue
     if check(L,T) or check(R,T):
          print('Yes')
          exit()
print('No')

Solution (Python):

import sys
input = sys.stdin.readline


def calc_y(vy, t):
    return vy*t - g/2*t*t


def loc(y, b, t):
    if y < b+eps:
        return -1
    if y > t-eps:
        return 1
    return 0


def can_hit(x, y):
    if x == 0:
        return False
    a = g*g/4
    b = g*y-V*V
    c = x*x+y*y
    D = b*b-4*a*c
    if D < -eps:  
        return False
    if -eps <= D < 0:
        D = 0
    for d in [-1, 1]:
        t2 = (-b+d*D**.5) / (2*a)
        if t2 <= 0:
            continue
        t = t2**.5
        vx = x/t
        vy = y/t + g/2*t
        if calc_y(vy, X/vx) < Y-eps:  
            continue
        maxt = vy/g
        maxx = vx*maxt
        maxy = calc_y(vy, maxt)
        for L, B, R, T in obstacles:
            left = loc(calc_y(vy, L/vx), B, T)
            right = loc(calc_y(vy, R/vx), B, T)
            if left*right <= 0:
                break
            if L <= maxx <= R:
                mid = loc(maxy, B, T)
                if left*mid <= 0:
                    break
        else:
            return True
    return False


g = 9.8
eps = 1e-10
N, V, X, Y = map(int, input().split())
obstacles = []
for _ in range(N):
    L, B, R, T = map(int, input().split())
    R = min(R, X)
    if L <= X:
        obstacles.append((L, B, R, T))
if X == 0:
    if V*V/(2*g) < Y-eps:
        print('No')
        exit()
    for L, B, R, T in obstacles:
        if B < Y:
            print('No')
            exit()
    print('Yes')
    exit()


if can_hit(X, Y):
    print('Yes')
    exit()

for L, B, R, T in obstacles:
    if can_hit(L, T) or can_hit(R, T):
        print('Yes')
        exit()
print('No')