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



Sample input:
0 7 3 1


Sample output:
Yes

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
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')

Submission status: Accepted

Solution code:
# aoj 2308
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:  # cannot reach
        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:  # cannot go above the pig
            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()

# hit directly
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')