It is unrated like every previous educational round. Sorry that it isn't mentioned in the post.

You can unregister 2 contests at the same time :D

OMG!!! Somebody is very angry...

If you don't like, you can unjoin and nobody force you to register it.

I see a lot of people apologizing for their English here. Why ? It is not like English is your first language. Chill man.

No. Read about education round.

they don't understand the true value of contest

Yay. I totally agree with you :)

The organizer must have predicted this issue would happen and announced the round to be unrated before the round had started.

I fixed, I found that i tried to maximize y/x, but actually we need to minimize it

Try this case

1
1000

i am not sure but i guess maintain an upper convex hull of points and checking if the query points are inside or not should work , something like this.

It can be solved with geometry, we have to support two operations:

1. add one point (mana cost, damage) and keep the convex hull of all the points so far.

2. determine if after scaling the convex hull by t it intersects the rectangle (Maximum mana, Health)

Fixed!

Fixed

notice that all values in left subtree < value at current node and all values in right subtree > current node and all values in this subtree are in some range [l , r] and the value at current node is (l + r) / 2. Using this you can find the node u in log(N) the same way as you find stuff in a binary search tree and then continue the traversal there while mainting the list of ancestors of a node.

I used two variables l and r to mark the leftmost (smallest) number and rightmost (largest) number of the subtree of current node.

For 'L' and 'R' operations:

When l = r, it means that the current node is at the deepest layer, so we should ignore these operations. Otherwise, shrink the range by making l = mid+1 for 'R' operations, or r = mid-1 for 'L' operations, where mid = (l+r)/2 (the current node).

For 'U' operations:

When l = 1 and r = n, it means that the current node is the root, and we should ignore this operation. Otherwise, check the (x+1)th bit where xth bit is the lowest bit containing 1. If that bit is 1, the current node is in the right subtree of its parent. If that bit is 0, the current node is in the left subtree of its parent. Expand the range by moving l and r pointers.

I made a function that receives a number x and returns info = {value, level, left/right, difference with parent} about it in log(n).
You can observe that for node x, value of left child is x-dif, value of right child is x+dif. dif reduces by 2 on each level.
Using this, it becomes easy to process up, left and right queries.
Here is AC code.
Here is same code with comments.

1. Let the number of ball in box noted a1 a2 ... an;
2. First you will find the minimum ai in this array (marked as ak).
3. Then, let's enumerate all size as (ak/1, ak/2, ... ak/ak), let pki = ak/i, if (ak%i == 0) we will try that (pki, pki+1) and (pki, pki-1), otherwise, we wil try (pki, pki+1);
4. If we discover a pair (pkj, pkj+1) can combinate all box(a1,a2,...an), then we find the maximum size of set is (pkj, pkj+1);
5. Output the sum of Pi = ai/(pkj+1) (PS: if (ai%(pkj+1)) != 0 then Pi = Pi + 1) for answer.

Find K = sum%3. If its 0, you are done.
Otherwise, you have to remove at max 2 elements to make it a multiple of 3.
So there are few cases only that you have. I maintained a vector of pair for both cases, when K is 0 and when its 1. Find for each case the resultant string and take the one with minimum deletions. (Also for more optimization you won't remove digits like 3,6,9 anyway.) Here is the code.

It can be solved by dynamic programming.

I think the method you decide if a node is a left child or right child is wrong, because everything else that you said is like mine solution. Instead of checking if current_node is a right child or left child by some formula, I simply keep a stack on the moves I have made. You can look at my solution if you want 25872554

Here:)

Maybe the stl is different.

Well, when I switch to c++14 from c++11 I got more YES, but still wa on test 3. I feel quite confused.

In problem A, Anti-quicksort hack cases work.

Java has a method called Arrays.sort(); that uses a quick sort method to sort an array. Quick sort's average run time is O(nlogn), but it's worst case scenario sort is O(n^2). People used a worst case scenario input/generator to hack many java solutions.

P.S. To fix this just use Integer instead of int for your array since to sort objects, java uses a merge sort instead, which runs in time.

We don't iterate from i = 1 to , instead it's up to . When you want to divide some a_i into k sets, each set will be of size . Therefore or . Thus, it's possible to check every case by checking up to the root. Since on each iteration we iterate over our array of size n, the time complexity of the solution is