Problem: Takahashi is meeting up with Aoki.  They have planned to meet at a place that is D meters away from Takahashi's house in T minutes from now.  Takahashi will leave his house now and go straight to the place at a speed of S meters per minute.  Will he arrive in time?

Submission attempts (in order):
import os
import sys

import numpy as np


def solve(inp):
    RBST_CHILDREN = []
    RBST_VALUES = []
    RBST_COUNTS = []
    RBST_INDICES = []
    RBST_ROOTS = []

    def rbst_init():
        lst = [0]
        lst.clear()
        RBST_CHILDREN.append([[0], [0]])
        RBST_VALUES.append([0])
        RBST_COUNTS.append([0])
        RBST_INDICES.append(lst)
        RBST_ROOTS.append(0)
        return len(RBST_ROOTS) - 1

    def rbst_merge(ins, left_root, right_root):
        children = RBST_CHILDREN[ins]
        counts = RBST_COUNTS[ins]
        li = left_root
        ri = right_root
        stack = []
        while li != 0 and ri != 0:
            if np.random.randint(counts[li] + counts[ri]) < counts[li]:
                stack.append((li, 1))
                li = children[1][li]
            else:
                stack.append((ri, 0))
                ri = children[0][ri]

        i = li if li != 0 else ri
        while stack:
            pi, is_right = stack.pop()
            children[is_right][pi] = i
            counts[pi] = counts[children[0][pi]] + counts[children[1][pi]] + 1
            i = pi

        return i

    def rbst_split(ins, x, root=-1):
        children = RBST_CHILDREN[ins]
        values = RBST_VALUES[ins]
        counts = RBST_COUNTS[ins]
        if root == -1:
            root = RBST_ROOTS[ins]
        i = root
        l_stack = []
        r_stack = []
        while i != 0:
            if x < values[i]:
                r_stack.append(i)
                i = children[0][i]
            else:
                l_stack.append(i)
                i = children[1][i]

        li, ri = 0, 0
        while l_stack:
            pi = l_stack.pop()
            children[1][pi] = li
            counts[pi] = counts[children[0][pi]] + counts[li] + 1
            li = pi
        while r_stack:
            pi = r_stack.pop()
            children[0][pi] = ri
            counts[pi] = counts[ri] + counts[children[1][pi]] + 1
            ri = pi

        return li, ri

    def rbst_insert(ins, x):
        children = RBST_CHILDREN[ins]
        values = RBST_VALUES[ins]
        counts = RBST_COUNTS[ins]
        indices = RBST_INDICES[ins]

        if indices:
            ni = indices.pop()
            children[0][ni] = children[1][ni] = 0
            values[ni] = x
            counts[ni] = 1
        else:
            ni = len(values)
            children[0].append(0)
            children[1].append(0)
            values.append(x)
            counts.append(1)

        li, ri = rbst_split(ins, x)
        i = rbst_merge(ins, li, ni)
        i = rbst_merge(ins, i, ri)
        RBST_ROOTS[ins] = i

    def rbst_delete(ins, x):
        children = RBST_CHILDREN[ins]
        counts = RBST_COUNTS[ins]
        indices = RBST_INDICES[ins]

        li, mri = rbst_split(ins, x - 1)
        mi, ri = rbst_split(ins, x, mri)

        if mi == 0:
            RBST_ROOTS[ins] = rbst_merge(ins, li, ri)
            return

        if counts[mi] == 1:
            indices.append(mi)
            RBST_ROOTS[ins] = rbst_merge(ins, li, ri)
            return

        i = mi
        stack = []
        while i != 0:
            if children[0][i] != 0 and children[1][i] != 0:
                to_right = 1 if counts[children[0][i]] < counts[children[1][i]] else 0
                stack.append((i, to_right))
                i = children[to_right][i]
            else:
                if children[0][i] != 0:
                    if stack:
                        pi, is_right = stack[-1]
                        children[is_right][pi] = children[0][i]
                    else:
                        mi = children[0][i]
                elif children[1][i] != 0:
                    if stack:
                        pi, is_right = stack[-1]
                        children[is_right][pi] = children[1][i]
                    else:
                        mi = children[1][i]
                else:
                    pi, is_right = stack[-1]
                    children[is_right][pi] = 0
                break

        indices.append(i)
        while stack:
            pi, _ = stack.pop()
            counts[pi] -= 1

        i = rbst_merge(ins, li, mi)
        i = rbst_merge(ins, i, ri)

        RBST_ROOTS[ins] = i

    def rbst_lower_bound(ins, x, default):
        children = RBST_CHILDREN[ins]
        values = RBST_VALUES[ins]
        counts = RBST_COUNTS[ins]
        i = RBST_ROOTS[ins]
        y = default
        c = counts[i]
        j = 0
        while i != 0:
            if x <= values[i]:
                y = values[i]
                c = j + counts[children[0][i]]
                i = children[0][i]
            else:
                j += counts[children[0][i]] + 1
                i = children[1][i]
        return y, c

    def rbst_get_k_th(ins, k, default):
        children = RBST_CHILDREN[ins]
        values = RBST_VALUES[ins]
        counts = RBST_COUNTS[ins]
        i = RBST_ROOTS[ins]

        if counts[i] <= k:
            return default
        j = k
        while i != 0:
            left_count = counts[children[0][i]]
            if left_count == j:
                return values[i]
            elif left_count > j:
                i = children[0][i]
            else:
                j -= left_count + 1
                i = children[1][i]
        return default

    h = inp[0]
    w = inp[1]
    aaa = inp[2::2]
    bbb = inp[3::2]

    ins1 = rbst_init()
    ins2 = rbst_init()
    INF = 10 ** 18

    for i in range(1, w + 1):
        rbst_insert(ins1, i)
        rbst_insert(ins2, 0)
    rbst_insert(ins1, INF)
    rbst_insert(ins2, INF)

    moves = np.zeros(w + 1, dtype=np.int64)
    ans = np.full(h, -1, dtype=np.int64)

    for row in range(h):
        a = aaa[row]
        b = bbb[row]
        c, _ = rbst_lower_bound(ins1, a, INF)
        stack = []
        while c <= b + 1:
            stack.append(c)
            c, _ = rbst_lower_bound(ins1, c + 1, INF)

        if len(stack) == 0:
            ans[row] = row + 1 + rbst_get_k_th(ins2, 0, INF)
            continue

        found_nearest = b == w

        while stack:
            c = stack.pop()
            if found_nearest:
                rbst_delete(ins1, c)
                rbst_delete(ins2, moves[c])
            else:
                if c < b + 1:
                    rbst_delete(ins1, c)
                    rbst_insert(ins1, b + 1)
                    rbst_delete(ins2, moves[c])
                    rbst_insert(ins2, moves[c] + b + 1 - c)
                    moves[b + 1] = moves[c] + b + 1 - c

                found_nearest = True

        move = rbst_get_k_th(ins2, 0, INF)
        if move == INF:
            break

        ans[row] = row + move + 1

    return ans


def debug_print(children, values, counts, root):
    print(children.T)
    print(values)
    print(counts)
    _debug_print(children, values, counts, root, 0)


def _debug_print(children, values, counts, i, depth):
    if i != -1:
        _debug_print(children, values, counts, children[i, 0], depth + 1)
        print('      ' * depth, values[i], counts[i])
        _debug_print(children, values, counts, children[i, 1], depth + 1)


if sys.argv[-1] == 'ONLINE_JUDGE':
    # from numba.pycc import CC
    #
    # cc = CC('my_module')
    # cc.export('solve', '(i8[:],)')(solve)
    # cc.compile()

    import base64
    import subprocess

    # with open('my_module.tar.bz2', 'rb') as rh, open('my_module.txt', 'w') as wh:
    #     bin = str(base64.b85encode(rh.read()), encoding='utf8')
    #     wh.write(bin)

    bin = 'LRx4!F+o`-Q&}8X>j?x8_5c6>|NsC0|NsC0|NsC0|NsC0|NsC0|NsC0|NsC0|NsBvx5<T`?(OOxx&QzG000-MMF0Q*006x10DS|6paan6&!Er>000Bf0Awf>04M+fKndevwwvvcI;le-Mt}f108vk1eSPr9Me0T>yK*`(n)>xU+TO<Wl$dvOcb3|soltf3yy<(}z3*$F63A!*1{Q4gY44PgPrY%<+a|PU4b*!n?ld1-kdm7FjNxwp002G%>r+rFl;--2pf29uDv;sJb=AYr0&ZX(0ra4tcQvn}@&V

    with open('my_module.tar.bz2', 'wb') as wh:
        wh.write(base64.b85decode(bin))

    subprocess.run(['tar', 'xvjf', 'my_module.tar.bz2'])

    exit()

if os.name == 'posix' or True:
    try:
        
        from my_module import solve
    except ModuleNotFoundError:
        print('WA')
        exit()
else:
    from numba import njit

    solve = njit('(i8[:],)', cache=True)(solve)
    print('compiled!', file=sys.stderr)

inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ')
ans = solve(inp)
print('\n'.join(map(str, ans)))


d, t, s = map(int, input().split())
print('Yes' if t * s >= d else 'No')


Verdicts: Wrong Answer

Accepted