Problem:
Problem D: Separate Points Numbers of black and white points are placed on a plane. Let's imagine that a straight line
of infinite length is drawn on the plane. When the line does not meet any of the points, the
line divides these points into two groups. If the division by such a line results in one group
consisting only of black points and the other consisting only of white points, we say that the
line "separates black and white points". Let's see examples in Figure 3. In the leftmost example, you can easily find that the black and
white points can be perfectly separated by the dashed line according to their colors. In the
remaining three examples, there exists no such straight line that gives such a separation.   Figure 3: Example planes  In this problem, given a set of points with their colors and positions, you are requested to decide
whether there exists a straight line that separates black and white points. Input The input is a sequence of datasets, each of which is formatted as follows. n m x 1 y 1 x n y n x n +1 y n +1 x n + m y n + m The first line contains two positive integers separated by a single space; n is the number of black
points, and m is the number of white points. They are less than or equal to 100. Then n + m lines representing the coordinates of points follow. Each line contains two integers x i and y i separated by a space, where ( x i , y i ) represents the x -coordinate and the y -coordinate of the i -th
point. The color of the i -th point is black for 1 ≤ i ≤ n , and is white for n + 1 ≤ i ≤ n + m . All the points have integral x - and y -coordinate values between 0 and 10000 inclusive. You can
also assume that no two points have the same position. The end of the input is indicated by a line containing two zeros separated by a space. Output For each dataset, output " YES " if there exists a line satisfying the condition. If not, output
" NO ". In either case, print it in one line for each input dataset. Sample Input 3 3
100 700
200 200
600 600
500 100
500 300
800 500
3 3
100 300
400 600
400 100
600 400
500 900
300 300
3 4
300 300
500 300
400 600
100 100
200 900
500 900
800 100
1 2
300 300
100 100
500 500
1 1
100 100
200 100
2 2
0 0
500 700
1000 1400
1500 2100
2 2
0 0
1000 1000
1000 0
0 1000
3 3
0 100
4999 102
10000 103
5001 102
10000 102
0 101
3 3
100 100
200 100
100 200
0 0
400 0
0 400
3 3
2813 1640
2583 2892
2967 1916
541 3562
9298 3686
7443 7921
0 0 Output for the Sample Input YES
NO
NO
NO
YES
YES
NO
NO
NO
YES

Solution (Python):
from collections import defaultdict
import sys
readline = sys.stdin.readline
write = sys.stdout.write

def dot3(O, A, B):
    ox, oy = O; ax, ay = A; bx, by = B
    return (ax - ox) * (bx - ox) + (ay - oy) * (by - oy)
def cross3(O, A, B):
    ox, oy = O; ax, ay = A; bx, by = B
    return (ax - ox) * (by - oy) - (bx - ox) * (ay - oy)
def dist2(A, B):
    ax, ay = A; bx, by = B
    return (ax - bx) ** 2 + (ay - by) ** 2
def is_intersection(P0, P1, Q0, Q1):
    C0 = cross3(P0, P1, Q0)
    C1 = cross3(P0, P1, Q1)
    if C0 == C1 == 0:
        E0 = dot3(P0, P1, Q0)
        E1 = dot3(P0, P1, Q1)
        if not E0 < E1:
            E0, E1 = E1, E0
        return 0 <= E1 and E0 <= dist2(P0, P1)
    D0 = cross3(Q0, Q1, P0)
    D1 = cross3(Q0, Q1, P1)
    return C0 * C1 <= 0 and D0 * D1 <= 0

def convex_polygons_intersection(ps, qs):
    pl = len(ps); ql = len(qs)
    i = j = 0
    while (i < pl or j < ql) and (i < 2*pl) and (j < 2*ql):
        px0, py0 = ps0 = ps[(i-1)%pl]; px1, py1 = ps1 = ps[i%pl]
        qx0, qy0 = qs0 = qs[(j-1)%ql]; qx1, qy1 = qs1 = qs[j%ql]

        if is_intersection(ps0, ps1, qs0, qs1):
            return 1

        ax = px1 - px0; ay = py1 - py0
        bx = qx1 - qx0; by = qy1 - qy0

        v = (ax*by - bx*ay)
        va = cross3(qs0, qs1, ps1)
        vb = cross3(ps0, ps1, qs1)

        if v == 0 and va < 0 and vb < 0:
            return 0
        if v == 0 and va == 0 and vb == 0:
            i += 1
        elif v >= 0:
            if vb > 0:
                i += 1
            else:
                j += 1
        else:
            if va > 0:
                j += 1
            else:
                i += 1
    return 0

def convex_hull(ps):
    qs = []
    n = len(ps)
    for p in ps:
        while len(qs)>1 and cross3(qs[-1], qs[-2], p) >= 0:
            qs.pop()
        qs.append(p)
    t = len(qs)
    for i in range(n-2, -1, -1):
        p = ps[i]
        while len(qs)>t and cross3(qs[-1], qs[-2], p) >= 0:
            qs.pop()
        qs.append(p)
    return qs

def inside_convex_polygon(p0, qs):
    L = len(qs)
    left = 1; right = L
    q0 = qs[0]
    while left+1 < right:
        mid = (left + right) >> 1
        if cross3(q0, p0, qs[mid]) <= 0:
            left = mid
        else:
            right = mid
    if left == L-1:
        left -= 1
    qi = qs[left]; qj = qs[left+1]
    v0 = cross3(q0, qi, qj)
    v1 = cross3(q0, p0, qj)
    v2 = cross3(q0, qi, p0)
    if v0 < 0:
        v1 = -v1; v2 = -v2
    return 0 <= v1 and 0 <= v2 and v1 + v2 <= v0

def solve():
    N, M = map(int, readline().split())
    if N == M == 0:
        return False

    P = [list(map(int, readline().split())) for i in range(N)]
    Q = [list(map(int, readline().split())) for i in range(M)]

    P.sort()
    Q.sort()
    if N > 2:
        P = convex_hull(P)[:-1]
    if M > 2:
        Q = convex_hull(Q)[:-1]

    if N < 3 or M < 3:
        if not N < M:
            N, M = M, N
            P, Q = Q, P
        ok = 0
        if N == 1:
            if M == 1:
                ok = 1
            elif M == 2:
                ok = not is_intersection(P[0], P[0], Q[0], Q[1])
            else:
                ok = not inside_convex_polygon(P[0], Q)
        elif N == 2:
            if M == 2:
                ok = not is_intersection(P[0], P[1], Q[0], Q[1])
            else:
                ok = not (inside_convex_polygon(P[0], Q) or inside_convex_polygon(P[1], Q))
                for i in range(M):
                    ok &= not is_intersection(P[0], P[1], Q[i-1], Q[i])
        write("YES\n" if ok else "NO\n")
        return True


    if (convex_polygons_intersection(P, Q)
            or inside_convex_polygon(P[0], Q)
            or inside_convex_polygon(Q[0], P)):
        write("NO\n")
    else:
        write("YES\n")
    return True
while solve():
    ...

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)

def _kosa(a1, a2, b1, b2):
    x1,y1 = a1
    x2,y2 = a2
    x3,y3 = b1
    x4,y4 = b2

    tc = (x1-x2)*(y3-y1)+(y1-y2)*(x1-x3)
    td = (x1-x2)*(y4-y1)+(y1-y2)*(x1-x4)
    return tc*td < 0

def kosa(a1, a2, b1, b2):
    return _kosa(a1,a2,b1,b2) and _kosa(b1,b2,a1,a2)

def distance(x1, y1, x2, y2):
    return math.sqrt((x1-x2)**2 + (y1-y2)**2)

def distance_p(a, b):
    return distance(a[0], a[1], b[0], b[1])

def distance3(p1, p2, p3):
    x1,y1 = p1
    x2,y2 = p2
    x3,y3 = p3

    ax = x2 - x1
    ay = y2 - y1
    bx = x3 - x1
    by = y3 - y1

    r = (ax*bx + ay*by) / (ax*ax + ay*ay)
    if r <= 0:
        return distance_p(p1, p3)
    if r >= 1:
        return distance_p(p2, p3)
    pt = (x1 + r*ax, y1 + r*ay, 0)
    return distance_p(pt, p3)

def ccw(a, b, c):
    ax = b[0] - a[0]
    ay = b[1] - a[1]
    bx = c[0] - a[0]
    by = c[1] - a[1]
    t = ax*by - ay*bx;
    if t > 0:
        return 1
    if t < 0:
        return -1
    if ax*bx + ay*by < 0:
        return 2
    if ax*ax + ay*ay < bx*bx + by*by:
        return -2
    return 0

def convex_hull(ps):
    n = len(ps)
    if n < 3:
        return ps[:]
    k = 0
    ps.sort()
    ch = [None] * (n*2)
    for i in range(n):
        while k >= 2 and ccw(ch[k-2], ch[k-1], ps[i]) <= 0:
            k -= 1
        ch[k] = ps[i]
        k += 1
    t = k + 1
    for i in range(n-2,-1,-1):
        while k >= t and ccw(ch[k-2], ch[k-1], ps[i]) <= 0:
            k -= 1
        ch[k] = ps[i]
        k += 1

    return ch[:k-1]

def main():
    rr = []

    def f(n,m):
        a = [LI() for _ in range(n)]
        b = [LI() for _ in range(m)]
        t = convex_hull(a + b)
        af = bf = False
        for c in t:
            if c in a:
                af = True
            else:
                bf = True
        if not af or not bf:
            return 'NO'
        d = convex_hull(a)
        e = convex_hull(b)
        dl = len(d)
        el = len(e)
        if dl > 1:
            for i in range(dl):
                d1 = d[i]
                d2 = d[(i+1) % dl]
                for j in range(el):
                    k = distance3(d1,d2,e[j])
                    if k < eps:
                        return 'NO'
                    if el > 1 and kosa(d1,d2,e[j],e[(j+1)%el]):
                        return 'NO'
        if el > 1:
            for i in range(el):
                e1 = e[i]
                e2 = e[(i+1) % el]
                for j in range(dl):
                    k = distance3(e1,e2,d[j])
                    if k < eps:
                        return 'NO'


        return 'YES'

    while 1:
        n,m = LI()
        if n == 0:
            break
        rr.append(f(n,m))

    return '\n'.join(map(str,rr))


print(main())

Solution (Python):
def dot(c1, c2):
    return c1.real * c2.real + c1.imag * c2.imag

def cross(c1, c2):
    return c1.real * c2.imag - c1.imag * c2.real

def on_segment(p, a, b):
    
    v1 = a - p
    v2 = b - p
    return cross(v1, v2) == 0 and dot(v1, v2) < 0

def ccw(p0, p1, p2):
    return cross(p1 - p0, p2 - p0) > 0

def intersect(p1, p2, p3, p4):
    crs1 = cross(p2 - p1, p3 - p1)
    crs2 = cross(p2 - p1, p4 - p1)
    if crs1 == 0 and crs2 == 0:
        return dot(p1 - p3, p2 - p3) < 0 or dot(p1 - p4, p2 - p4) < 0
    crs3 = cross(p4 - p3, p1 - p3)
    crs4 = cross(p4 - p3, p2 - p3)
    return crs1 * crs2 <= 0 and crs3 * crs4 <= 0

def andrew(point_list):
    
    u = []
    l = []
    u.append(point_list[0])
    u.append(point_list[1])
    l.append(point_list[-1])
    l.append(point_list[-2])
    
    for p in point_list[2:]:
        while ccw(u[-2], u[-1], p):
            u.pop()
            if len(u) == 1:
                break
        u.append(p)
    
    for p in point_list[-3::-1]:
        while ccw(l[-2], l[-1], p):
            l.pop()
            if len(l) == 1:
                break
        l.append(p)
    
    u.pop()
    l.pop()    
    return u + l

def contains(polygon, point):
    for p1, p2 in zip(polygon, polygon[1:] + polygon[:1]):
        a = p1 - point
        b = p2 - point
        cross_ab = cross(a, b)
        if cross_ab > 0:
            return False
        elif cross_ab == 0 and dot(a, b) > 0:
            return False
    return True

def string_to_complex(s):
    x, y = map(int, s.split())
    return x + y * 1j

def solve():
    from sys import stdin
    file_input = stdin
    lines = file_input.readlines()
    while True:
        n, m = map(int, lines[0].split())
        if n == 0 and m == 0:
            break
        
        if n == 1 and m == 1:
            print('YES')
            lines = lines[1+n+m:]
            continue
        
        pts1 = map(string_to_complex, lines[1:1+n])
        pts2 = map(string_to_complex, lines[1+n:1+n+m])
        
        if n == 1 and m == 2:
            if on_segment(next(pts1), *pts2):
                print('NO')
            else:
                print('YES')
                
        elif n == 2 and m == 1:
            if on_segment(next(pts2), *pts1):
                print('NO')
            else:
                print('YES')
                
        elif n == 2 and m == 2:
            if intersect(*pts1, *pts2):
                print('NO')
            else:
                print('YES')
        
        elif n == 1:
            p = next(pts1)
            cvx = andrew(sorted(pts2, key=lambda c: (c.real, c.imag)))
            if contains(cvx, p):
                print('NO')
            else:
                print('YES')
        
        elif m == 1:
            p = next(pts1)
            cvx = andrew(sorted(pts1, key=lambda c: (c.real, c.imag)))
            if contains(cvx, p):
                print('NO')
            else:
                print('YES')
        
        elif n == 2:
            p1, p2 = pts1
            cvx = andrew(sorted(pts2, key=lambda c: (c.real, c.imag)))
            if contains(cvx, p1) or contains(cvx, p2):
                print('NO')
            else:
                for p3, p4 in zip(cvx, cvx[1:] + cvx[:1]):
                    if intersect(p1, p2, p3, p4):
                        print('NO')
                        break
                else:
                    print('YES')
        
        elif m == 2:
            p1, p2 = pts2
            cvx = andrew(sorted(pts1, key=lambda c: (c.real, c.imag)))
            if contains(cvx, p1) or contains(cvx, p2):
                print('NO')
            else:
                for p3, p4 in zip(cvx, cvx[1:] + cvx[:1]):
                    if intersect(p1, p2, p3, p4):
                        print('NO')
                        break
                else:
                    print('YES')
        
        else:
            cvx1 = andrew(sorted(pts1, key=lambda c: (c.real, c.imag)))
            cvx2 = andrew(sorted(pts2, key=lambda c: (c.real, c.imag)))
            for p in cvx2:
                if contains(cvx1, p):
                    print('NO')
                    break
            else:
                for p in cvx1:
                    if contains(cvx2, p):
                        print('NO')
                        break
                else:
                    for p1, p2 in zip(cvx1, cvx1[1:] + cvx1[:1]):
                        for p3, p4 in zip(cvx2, cvx2[1:] + cvx2[:1]):
                            if intersect(p1, p2, p3, p4):
                                print('NO')
                                break
                        else:
                            continue
                        break
                    else:
                        print('YES')
        
        lines = lines[1+n+m:]

solve()