AreEduRoundsEducational :D

You know that can't be possible that everyone gets +delta.

Why not?

No.

It does matter whether you submit it early or late. And an additional 10 min penalty will be added for every wrong answer given you solve it later on. For ex. Look at Rank 1 in educational find 99. The accumulate time for all his solutions is 213 but he Made a wrong submission before solving the last problem so, 213+10 = 223(total penalty).

I felt same. Need more practice :(

lol not gonna lie you got us in the first half

same man A got me scratching my head

even though i came late and tried to solve A and B fast and here we go biggest negative delta

C was easier than usual though.

A destroyed me

are there penalty for incorrect submission?

Nice try, but it's not me this time.

Output either array $$$[1, a[2], 1, a[4], \dots]$$$, or array $$$[a[1], 1, a[3], 1 \dots]$$$. At least one of them will satisfy condition $$$2\sum\limits_{i=1}^{n}|a_{i}-b_{i}| \le S$$$.

I took nearest power of 2 for every number using log. Hence it will satisfy b[i] divisible by b[i+1] or b[i+1] divisible by b[i].

My approach was calculating the summation of odd indices elements and even indices elements. Then check which of these summations is minimum. If odd indices elements summation is minimum then even indices elements summation, print 1 instead of every odd index element and print the corresponding value from the given array for even indices. If even indices elements summation is minimum then do the vice versa.

same bro i went thinking in A then i could not get its code so i went to try in B then i was disappointed so i left the contest and went playing among us :)

https://codeforces.net/contest/1463/submission/101514209 You can look at my submission

You need to participate more then.

Even I felt the same

mmm Nice, problem C was hacked. Awesome round and great tests.

I just wanna ask if statement of C makes any sense coz it's the first time I have seen so less submissions to C in 1 and half hours, I am sorry if I am too blunt but I felt that the people who designed the problem C made it clear that most don't even get the question as even the examples and their explanation at the bottom were useless...

Your condition 2 may give a solution where, multiples, say, aX and bX (a>1, b>1), of X, might be adjacent in the resulting array. These adjacent elements may then not divide one another. Consider a=2, b=3.

Consider the array 2,2,2,2,4,6. The median is 2. You will then give the output 2,2,2,2,4,6. But 6 is not a multiple of 4.

Find the maximum and minimal value of x which can obtain the set B(just use two-pointer), and all values between them can also obtain the set B.

Let the array containing remaining elements be a.Sort both arrays b and a, now for each index either element from array a or b will be greater it will give us a value of x. Now we can handle the cases where elements from array a is greater and vice-versa separately (It can proved that swapping elements from these 2 sets won't affect x) to find the maximum number by which we can increase or decrease x. My Submission

My solution is, calculate the minimun numbers of min operations and max operations you have to use, note them as $$$needMi$$$ and $$$needMa$$$, then the rest of oprations can be any one of them. So, the answer will be $$$n - needMa - needMi + 1$$$.

And to calculate $$$needMi$$$，just iterate $$$b$$$ from index 1 to n. let $$$delta$$$ be the number of unused elements. Assume currently we are at index i, $$$max(x, b_i) = b_i$$$ stands for all numbers $$$x$$$ in range $$$(b_{i - 1}, b_i)$$$, so let $$$delta = delta + (b_i - b_{i - 1} - 1)$$$. If $$$delta = 0$$$, which means now we have to use min operation to get $$$b_i$$$. Else, just use max operation and comsume one unused numbers.

$$$needMa$$$ can be calculated out by the similar way.

accepted code

you can choose alternate 1,a[i] since either in a[1],1,a[2],1.... or in 1,a[1],1,a[2],.... sum of values copied directly will be at least half of the total sum .

Choose the closest power of 2 for every A[i]. Also ensure that it isnt above 1e9.

You can make two arrays depending on array a
Array a=a1,a2,a3,a4,a5
first array f=1,a2,1,a4,1
second array g=a1,1,a3,1,a5
One of these arrays will surely work
Proof:
let us calculate |a[i]-f[i]| =|a1-1|+|a3-1|+|a5-1|=a1+a3+a5-3
let us calculate |a[i]-g[i]| =a2+a4-2
Add these take average (a1+a2+a3+a4+a5-5)/2
This is obiviously less than (a1+a2+a3+a4+a5)/2

My approach was calculating the summation of odd indices elements and even indices elements. Then check which of these summations is minimum. If odd indices elements summation is minimum then even indices elements summation, print 1 instead of every odd index element and print the corresponding value from the given array for even indices. If even indices elements summation is minimum then do the vice versa.

Since $$$\sum\limits_{i=1}^{n}{|ai−bi|}$$$ $$$<=$$$ $$$S/2$$$. One way to achieve this would be to atleast subtract $$$a[i]/2$$$ from every $$$a[i]$$$.
And from this graph, we can say that
$$$2^{\operatorname{floor}\left(\log_{2}\left(x\right)\right)}$$$ > $$$\frac{x}{2}$$$
So the array B will be the $$$2^{\operatorname{floor}\left(\log_{2}\left(a[i]\right)\right)}$$$ for all $$$0<i<n$$$

You have to check (a + b + c) % 9 value, and some other things.

We have to make the HPs to 1, 1, 1 by exactly 7*k- 1(k is a positive integer) shots. In that 7*k- 1 shots, there are k-1 enhanced shots. So the total HPs that you damages is, 7*k- 1 + 2(k-1) = 9*k- 3. Thus, the total HPs that you should attack will be (9*k- 3) + 1 + 1 + 1 = 9*k.

So firstly, you need to check that (a + b + c) is divisible by 9.

I said "other things" at the above. There could be some situations that when you use k enhanced shots, you make all HPs to zero. These situations should have the answer "NO."

Approach for A:

a, b, c are health points.
After every 7th shot, total health is decreased by ( 1 + 1 + 1 + 1 + 1 + 1 + 3) = 9.
So after every 7 nth shot, health gets decreased by 9n.
So, you have to first check if (a + b + c) is divisible by 9, if it's not then you can in no way print "YES".

If the sum is divisible by 9, the only thing you have to check is min( a, b, c) >= n for "YES". 
Reason is, every 7 nth shot, each of your health point is compulsorily decreased by 1.

Else print "NO".

Please make streams on youtube as well. Is it possible?

Raw notes on problems A-F (taken live during stream): https://gist.github.com/stevenhao/b203645f59218ca59aaa4cbd447f8a61

Youtube video will be posted on my channel https://www.youtube.com/channel/UCl9IahGhVii0YrjdJvM1XNg

And I spent almost 2 hours to solve E.

you have to start the topological sort DFS from the head of each unvisited node.

Find maximum x and minimum x using binary search and subtract them

Well I got TLE in that test because I had a very stupid bug related to checking if the graph is cyclic. So maybe you have that error too.

every 7th round shoots all three of them , you didn't substract them from sum

You should find both the minimum and maximum of x.

My code : 101562193

What I think for this problem is that if any every array element can only be a max or min , then we decrease the answer by 1 (initially the answer was n+1) .

For checking if a number can only be a min , we count how many numbers smaller than the current number does not exist in the array (call it rem). Now we check how many previous elements can only be min (call it vs) . Now we check if rem + vs <= i (where i is the index of that element 0 based ) .

Now we do similar for checking if a number can only be min . We take the union of these two groups and subtract from answer .

My implementation for this approach : 101590810 Please give feedback for this solution .

can anyone suggest whether ladders help us to get better in rounds? Thanks in advance :)

same for me!couldn't solved even signle problem!

Should you also not unblock in your else part?

INF is too small. Made the same mistake during contest. :(

Or maybe Div1.5

problems played a mind game with me

Nearest power of 2 of X can't be more than two times bigger or more than two times lower than X

You could also make alternate elements as 1 .

I would totally disagree with that, I think it's easy to understand and hard to implement. Since solution is quite trivial( I think question itself tells what to do ).

And what's make C more difficult is 100 of hacks with just a small mistake from implementers