Just define a cycle as the total time for both Little B and Little K to work once and delete as many cycles as possible to reach the depth remaining. If the rest turns out within the reach of Little B (meaning that the rest is no more than $$$x$$$), output NO, else output YES.

public static void solve() throws Exception {
    int x = pn.nextInt(), y = pn.nextInt(), a = pn.nextInt();
    int cyclesComplete = a / (x + y);
    int rest = a - cyclesComplete * (x + y);
    so.println(rest + 0.5 > x ? "YES" : "NO");
}

Here pn and so stands for your customized I/O.

Actually it's not necessary to get the remaining depth after complete cycles. A user in the comment zone below pointed out that we can just use % to figure out the remaining depth for further calculations.

public static void solve() throws Exception {
    int x = pn.nextInt(), y = pn.nextInt(), a = pn.nextInt();
    so.println(a % (x + y) + 0.5 > x ? "YES" : "NO");
}

Here pn and so stands for your customized I/O.

Imagine that there is a $$$1$$$ in a non-topmost and non-leftmost cell of the $$$m\times n$$$ grid, which, beyond no doubt, indicates that there is a ball in the position — it should only happen when there has been a ball on its top or left side.

Therefore, if and only if there's no $$$0$$$ on the left (or top) side of the certain $$$1$$$ in the given matrix (top and left edge excluded) will the matrix be valid.

public static void solve() throws Exception {
    int n = pn.nextInt(), m = pn.nextInt();
    int[][] finalStateMat = new int[n][m];
    for (int i = 0; i < n; i++) {
        String finalStateRow = pn.nextLine();
        for (int j = 0; j < m; j++) {
            finalStateMat[i][j] = finalStateRow.charAt(j) - '0';
        }
    }
    boolean[] zeroExistsAlreadyOnRow = new boolean[n], zeroExistsAlreadyOnCol = new boolean[m];
    Arrays.fill(zeroExistsAlreadyOnCol, false);
    Arrays.fill(zeroExistsAlreadyOnRow, false);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (finalStateMat[i][j] == 0) {
                zeroExistsAlreadyOnCol[j] = true;
                zeroExistsAlreadyOnRow[i] = true;
            } else if (i*j!=0 && (zeroExistsAlreadyOnCol[j] && zeroExistsAlreadyOnRow[i])) {
                so.println("NO");
                return;
            }
        }
    }
    so.println("YES");
}

Here pn and so stands for your customized I/O.

Wrong idea had it in my initial mind that it would be okay once all $$$1$$$ cells have either a top neighbor or left one of $$$1$$$, the given grid will stand. However, the following test case will prove it wrong.

1
2 4
0100
0111

The problem disabled the ball to move in an L-shaped course, which makes the grid given by the test case above impossible to be reached.

For a table of which the bottom left cell is $$$(3x+1,3y+1)$$$, the minimum distance of the 4 cells on the table can be illustrated as follows:

Despite the fact that the dining hall is infinite, we can find out that tables where guests will sit can be taken as a isosceles right triangle whose vertex with right angle is $$$(1,1)$$$. Therefore, the maximum of tables should be no larger than the minimum of $$$r$$$ that $$$\frac{r(r+1)}{2}\ge50000$$$. That is to say, the max number of tables can be $$$r_{\min}=317$$$. So just create a list that stands for all the 317 tables, then label the cells with the corresponding minimum distances. Sort the distances afterwards — give the cells to the guests in order according to the number $$$t_i$$$ of them.

public static void solve() throws Exception {
    List<int[]> distanceBook = new ArrayList<>();
    if (!distanceBook.isEmpty())
        return;
    int tableMax = 317;
    for (int x = 0; x < tableMax; x++) {
        for (int y = 0; y < tableMax; y++) {
            distanceBook.add(new int[] { 3 * x + 3 * y + 1, 3 * x + 1, 3 * y + 1 });
            distanceBook.add(new int[] { 3 * x + 3 * y + 2, 3 * x + 1, 3 * y + 2 });
            distanceBook.add(new int[] { 3 * x + 3 * y + 2, 3 * x + 2, 3 * y + 1 });
            distanceBook.add(new int[] { 3 * x + 3 * y + 5, 3 * x + 2, 3 * y + 2 });
        }
    }
    // Sort coordinates according to distances
    Collections.sort(distanceBook, (a, c) -> {
        if (a[0] != c[0])
            return Integer.compare(a[0], c[0]);
        if (a[1] != c[1])
            return Integer.compare(a[1], c[1]);
        return Integer.compare(a[2], c[2]);
    });
    int n = pn.nextInt();
    int[] a = new int[n];
    for (int i = 0; i < n; i++) {
        a[i] = pn.nextInt();
    }
    int possibleOccupiedTableCount = (int) Math.sqrt(2 * n) + 3;
    int[][] seatOccupied = new int[possibleOccupiedTableCount * 3][possibleOccupiedTableCount * 3];
    int[][] tableOccupied = new int[possibleOccupiedTableCount][possibleOccupiedTableCount];
    int k1 = 0, k0 = 0;
    for (int i = 0; i < n; i++) {
        int x, y;
        if (a[i] == 1) {
            while (seatOccupied[distanceBook.get(k1)[1]][distanceBook.get(k1)[2]] != 0)
                k1++;
            x = distanceBook.get(k1)[1];
            y = distanceBook.get(k1)[2];
        } else {
            while (tableOccupied[distanceBook.get(k0)[1] / 3][distanceBook.get(k0)[2] / 3] != 0)
                k0++;
            x = distanceBook.get(k0)[1];
            y = distanceBook.get(k0)[2];
        }
        seatOccupied[x][y] = 1;
        tableOccupied[x / 3][y / 3] = 1;
        so.println(x + " " + y);
    }
}

Here pn and so stands for your customized I/O.

Thoughts had popped into my mind during the contest already that it is possible to calculate out the next guest's seat according to the current guest's $$$t_i$$$, but I don't know how to simulate it. Maybe it's because lack of experiences.

Suppose there is a prime number $$$x$$$. It can easily proved that for sequence $$$x,x-1,x+1,x-2,x+2,\cdots,1,2x-1$$$ (let’s mark it as {$$$t_n$$$}) and $$$c_i=\lceil\frac{\sum_{k=1}^it_k}{i}\rceil$$$, it stands that $$$c_i=x$$$ and, hence, that $$$c_i$$$ is prime.

Having taken above into account, the more coverage of {$$$t_n$$$} on the expected permutation, the more prime numbers {$$$c_n$$$} will feature. So just find the nearest prime number to the half of $$$n$$$ and try to make permutations with initials mentioned above — output the rest (the numbers may range from $$$2x-1$$$ to $$$n$$$ or from $$$1$$$ to $$$2x-n$$$) in random order.

public static void solve() throws Exception {
    int n = pn.nextInt();
    if (n == 2) {
        so.println("2 1");
        return;
    } else if (n == 3) {
        so.println("2 1 3");
        return;
    } else if (n == 4) {
        so.println("2 1 3 4");
        return;
    } else if (n == 5) {
        so.println("2 1 3 4 5");
        return;
    }
    int findPrimeIndicator = n / 2;
    int leftPrime=findPrimeIndicator, rightPrime=findPrimeIndicator;
    do{
        leftPrime--;
    } while (!isPrime(leftPrime));
    do{
        rightPrime++;
    } while (!isPrime(rightPrime));
    findPrimeIndicator = Math.abs(findPrimeIndicator - leftPrime) > Math.abs(findPrimeIndicator - rightPrime)
        ? rightPrime
            : leftPrime;
    so.print(findPrimeIndicator + " ");
    if (findPrimeIndicator == leftPrime) {
        // output x-1~1 cycle
        for (int i = 1; i < findPrimeIndicator; i++) {
            int left = findPrimeIndicator - i, right = findPrimeIndicator + i;
            so.print(left + " " + right + " ");
        }
        for (int i = 2 * findPrimeIndicator; i <= n; i++) {
            so.print(i + " ");
        }
        so.println("");
        return;
    } else {
        // output x+1~n cycle
        for (int i = 1; i <= n - findPrimeIndicator; i++) {
            int left = findPrimeIndicator - i, right = findPrimeIndicator + i;
            so.print(left + " " + right + " ");
        }
        for (int i = 1; i < 2 * findPrimeIndicator - n; i++) {
            so.print(i + " ");
        }
        so.println("");
        return;
    }
}

public static boolean isPrime(int p) {
    if (p < 2)
        return false;
    for (int i = 2; i <= (int) Math.sqrt(p); i++) {
        if (p % i == 0)
            return false;
        }
    return true;
}

Here pn and so stands for your customized I/O.

I got confused with the difference between permutation and array during the contest — things will be greatly easier if the problem asks for array, as we can just give a sequence that features all-$$$1$$$ elements except the first one (which can be $$$2$$$).

The code above has to process $$$n=2,3,4,5$$$ first in that half of them are no more than 2, the minimum of all non-negative prime numbers.

The approach to the problem mentioned above should reach the maximum number of the prime $$$c_i$$$ s, but how to prove the number to be greater than asked is still a question. ( UPD: the proof has been obtained by Tamas' blog.) From my point of view, the intensity of prime numbers is still medium before $$$10^5$$$ and that’s why this code block can work — for larger $$$n$$$, maybe the idea should be switched.