(Higher on the street)

And I know it's my time to go

nice photo

Nice but who asked

mine was 145th one excited to know how you roasted :)

happily you got >=0 upvotes, otherwise saarang would roast you lol

but you had 1725...

I hate Interactive Problems

We did this intentionally, as it is well-known that all problems are well-known in China

It's probably gonna be easy, but I don't think it will be rated less than 800. I haven't seen any problems rated below that even if they are very easy

Not just any anime girl.

i am too!

8 downvotes. Does this mean Saarang roasted you?

Until you become pupil.

hussenberg you seem kinda sus ngl

1. Read the problem.
2. Think hard.
3. Write down the solution.

Competitive programming = speed + knowledge

Took me a long time to debug, though got the approach early.

I would say the same for E.

i am hard stuck at C for the entire round. Need to learn how to move on to D.

When you have more than 2 negative or more than 2 positive integers, the answer is NO (think why). Now you can save min(cnt0, 3) zeros and check the condition on array of size less than 10.

I hate this round!!!

Probably it has to do something with a number of numbers that are in range (l, r) for a particular segment, but I couldn't elaborate this idea.

Query on segments like [1, x].
Let miss be count of integers between 1 and x, such that they are not present in query result.
For even and odd segment lengths, think about what should be the parity of miss if answer <= x and if answer > x

If 3 positive or 3 negative, answer is not possible.

Otherwise, brute force.

Hint:Notice that the number of non-zero numbers must be very small.

3sum-closed array has at most 2 negative numbers, and at most 2 positive numbers. Then reduce zeros to some small value, so we can iterate all i, j, k and check all sums.

Yea should pass, why not

Umm... we can never have more than 2 positive/negative integers?? So if the count of odd or neg numbers is >2 then the answer will be "NO"

Hi! It's my first time for me solving E, i'm very happy, so lemme write my solution;)

Let's notice that if we are given a certain permutation b we can only change a to b when for each element a[i] if j is the position we should move a[i] to, b[j] <= a[i] + s:

If the condition is not true (for example for a[i], if a[i] should be on j-th place) — then we can't move a[i] to its needed place, because if we can, then we do it on move <=i therefore other element we swap (a[j]) has a difference with a[i] no more than s, but a[j] > a[i] + s (contradiction)

If the condition is true for each a[i], notice that we can consequently move a[i] to its needed position on a[i]-th move (legally).

So let's find all permutations which suit the condition:

Firstly, for each a[i] if b[i] is already not -1, then b[i] must be no more than a[i] + s (condition 1), otherwise answer is 0 (same reasons as in 2nd paragraph)

Assume 1st condition is true: lets say that we have c[1] < c[2] < ... < c[x] — elements of array a, under theis indexes in array B stand -1s. And we have d[1] < d[2] ... < d[x] — elements we have to insert in B on places of -1s.

After substracting s from each d[i], a suitable permutation will be when for every d[j] standing under element Y from A, y>=d[j]. (same reasons as in 2nd paragraph)

So for each d[i] we can find under how much elements of C it can stand (when I say stand under, i mean that they have same index, it's just my visualisation that array B stands under array A) using binary search Let's notice that if b[j] > b[i], on every position we can put b[j], we can also put b[i]. So let's choose a suitable permutation consequently choosing a place for d[1], then for d[2], and so on. if we can place d[i] onto z places, then if we already placed first i-1 elements of D, then we can choose a place for d[i] by z-(i-1) variants.

Let's notice that if we can put d[i] on z<i places, then we can place first i elements of D on z<i places (contradiction, so answer is 0) (condition 2)

In the other case, if d[i] can be put on e[i] places, answer is (e[1]-0) * (e[2] — 1) * ... * (e[i] — (i-1)) * ... * (e[n] — (n-1)) (mod 998244353).

Sorry for my bad english, of if you didn't understand something) i hope you will understand me))

I misread the problem C, I thought one fulfilling pair was enough.

I think that the problems had classic prototypes like:

A — xoring to find the unique number

C — 2Sum or 3Sum problem

F — reversing an array via Implicit Treap

3-SUM was reference to recent div4, PermutationForces was reference to one of recent problems too (don't remember the contest), pretty much sure all other problem names you could've meet before.

What else would it be? For even one such $$$i, j, k$$$?

one hour is wasted on that thing, I really gotta read the problem statement carefully the next time.

it's very sad that your rating is 2100, not 2099

I waste too much time because of misreading the statement of E so that I didn't have time thinking about G.

Anyway, the problems are very impressive and a bit more difficult than normal Div2. Really like this contest.

Good problem..but number of queries was a direct hint to binary search..If number of queries were hidden,it would have been a even better problem.

Failed systest because I didn't see the 3a, a, -a, -a case. :(

-3a -a a a

Run your program with and without it and you will see

It shouldn't, however if you defined "endl" as "\n" it will because \n does not flush the stream and you were explicitly asked to flush your streams.

however, if you remove that def, the streams are flushed automatically https://stackoverflow.com/a/31165481/

You can print any of the elements

I think it can be any element

Can you elaborate a lil?

dont use unordered map