It needs to be balanced, one should not feel like he wasted time solving C and D if E wasn't that hard but worth much more points, converse is also true. I hope you get what I am trying to say.

Not revealing score distribution too early doesn't mean it takes so much time for setters. It might change someone's strategy at the beginning of the contest.

Procrastination

As a tester I feel bad that you didn't tag me :-(

it's a trap!

I wish the formal statement should be in bold.

Bro you are trying since 6 years on codeforces why you still a Specialist. Is there any mistake you are making, please give some experience advice also mistake you have made i'm a beginner here want to learn from you :).

Sorry drifter_kabir Mridul323, If you taken it in negative i'm worried as i wasted my 2 years in college and started cp too late would i get job or not :( does not have any right direction how to improve in that less time.

You just need to connect with author or coordinator to test the round.

What was that, and who are you? :D

I also thinks so. Might be Mike and his team are planning to do something against cheaters, because from past 3-4 months everyone knows what is happening...

Good luck on nullifying ur negative contribution( https://mirror.codeforces.com/blog/entry/86882?#comment-749682 ).

As a participant, I wish the same.

❤❤

Learn to stay in the present.

I couldn't solve one for this round :(. It's damn tough.

Short statements are good but I think in contests like ICPC one can struggle if he doesn't have the habit of reading long statements and find the real problem out of it.

sometimes when you open this site , the Russian version is displayed, select the English option in right top corner.

All the best.

Thanks for this motivation. My graph has been somewhat like this.

Unfortunately it's going to be like this for me today...

You must register at least 5 minutes before the start of the round

Me. I literally skipped it.

the answer is LCM of 2-th and 3-th primary numbers, and diff between each prime numbers should be >= than d

find next prime number for 1+d and then next prime number for (previous prime number)+d.

i guess your approach is correct ..you are missing somewhere else i think

I did brute force , because when we fix the first two numbers , the whole process becomes fixed . I don't know if it will pass system test.

What's unbalanced about it?

Let dp1[i] means if you only consider the piles in [1,i] and make every piles in [1,i-1] empty, the number of stones in i. Specially, dp1[i] = -1 if you can't make every piles in [1,i-1] empty.

Similarly, let dp2[i] means if you only consider the piles in [i,n] and make every piles in [i+1,n] empty......

So, not considering the swap opertion, we can see that if for some i, dp1[i]=dp2[i+1]&&dp1[i]!=-1, the answer is YES.

For swap operation, just iterate for the position you swap and get the new dp value near the swapped positions, which is O(1).

If you do not have two consecutive digits equal, you get the maximum length number. Going from left to right the first integer, you try to have in d the largest possible number, different from the previous one

Here comes the key observation. let max(array) = M.

1. M should consist in the first pair. if we don't choose the biggest element, (next 'x') <= M, since all elements are positive, we can't eliminate M since M+1 > x

2. If the first pair is chosen, choosing the rest automatically completes. Let's choose the first pair arbitrary. Eliminate the pair from the array. Then the next 'x' is M. by 1., we should choose the biggest element from the remaining array. But this time we know the sum of the pairs. Now, the pair automatically completes since we know one element and the sum of two elements.

After choosing the first pair by brute force, we can complete all the steps in N log N using multiset. The number of possible 'first pair' is N-1. So we can complete the algorithm in O(N^2 log N).

Hint: For a particular x you must select two integers where one of them is the max of remaining elements.

My solution’s complexity for C was O(N^2). I used a hashmap.

My $$$O(n^2 log n)$$$ passed in like 400 ms

How did you solve C

Fun fact:This was div2 only round:)

how to solve C can u please elaborate your approach thanks in advance !!

Just find the prime numbers upto 10^7 and select the prime numbers at minimum possible distance from d.

First divisor = 1

Second divisor = (nearest prime number to 1+d)

Third divisor = (nearest prime number to Second divisor + d)

Fourth Divisor = The number itself

Answer = Second Divisor * Third Divisor

You have to just find the product of first two prime numbers such that the difference between (1,p1) and (p1,p2) is atleast d where p1<p2.

Problem B was more logic than maths.

Same here. It doesn't even go past pretest 2 in Java using TreeMap.

You could avoid the logn factor by using a count array instead of a map(as A[i]<1e6) and after each iteration instead of resetting the entire array you could only reset the values which occurred during that iteration. This solution has a bit more implementation but you would have to worry less about about fst.

can you please tell how you resolved it, i'm trying and it's still giving WA on pretest 2.

I didn't read the code carefully, See this comment for the correct answer.

1 , 5 , 11 , 55

There is n't much dp other than prefix sum calculation.My solution:- if we have to remove all piles lets start from 1st one as it has only one neighbour.so a[0]<=a[1] similarily a[2]>=a[1]-a[0],a[3]>=(a[2]-(a[1]-a[0])) so on.so our problem reduces to finding an array with atmost one swap such that after swap for each position if position is even sum of even indexed number(after swap) >=sum of odd indexed number(after swap).and at final position odd_sum[n-1]=even_sum[n-1] to ensure there is no piles remain at last.Now it is an well known prefix sum implementation problem.If any doubt plz comment.

Even this looks same, with some added lines to avoid MOSS:

I believe it because erase(int) will erase all of that number in the set, so then you may erase the begin() of an empty set, which will cause TLE.