he hasn't participated to rated contests for 6 months.

He hasn't participated in the last 6 months, so he has moved to the inactive section of codeforces.

You can see his profile.

Div 4 is not happening any time soon...

West coast be like: Aww I have to wake up early for CF contests

East coast: sleeps in until 10:25 and doesn't miss the contest

You sleep while we work It's not a statement, it's an order.

mike mirzayanov is from russia) so russians sleep at this time)

https://bfy.tw/Ormx

In normal Div 2 ,weightage is different for all question, but in Educational contest weightage is same for all questions,and Ranking is based on penalty and no. of questions.

smh people changing comment content to avoid getting more downvotes

No No No!!! another bad nightmare.

Do you mean specialist?

• Every question has equal weight-age
• 12 hour open hacking phase
• Some problems are standard/classical

for destroying participants by bad ordering of problems

good luck

Tester think all problems are easy :(

B sucks

Luckly I jumped straight to C and got it early. Still didn't solve B tho...

Yes, E is exact copy of:

448 Problem C

I have idea just now. I could have done this. That irritating B costed me. Disgusting round. Don't order problems in terms of difficulty

What exactly is misleading in B and C statement?

448C - Painting Fence

This is an exact replica of that problem. How lucky (and hardworking) I am to have solved it!

dp[pos][k] where pos is the prefix we are at and k is the number of active 2nd type queries and gives minimum answer to make all elements till pos equal to 0

Iterate for $$$j$$$ and $$$k$$$, Now you need a index i such that $$$a_i = a_k$$$ and $$$i \lt j$$$, similarly, you need index $$$l$$$ such that $$$a_j = a_l$$$ and $$$k \lt l$$$, this suggests us to store two things.
$$$1$$$. $$$pref[i][j]$$$ be the number of times $$$j$$$ appeared from $$$1$$$ to $$$i$$$
$$$2$$$. $$$suff[i][j]$$$ be the number of times $$$j$$$ appeared from $$$i$$$ to $$$n$$$
Now, rest is quite easy.

There are only at max $$$n$$$ distinct numbers, so lets consider the case where each of them are used as $$$j$$$ and $$$l$$$, lets call this number the $$$divider$$$. So for each $$$divider$$$, we iterate left to right across the array, lets say the current number is $$$cur$$$. There are two cases:

1. $$$cur$$$ $$$\ne$$$ $$$divider$$$ — Then we want to add the number of pairs for which this position is $$$k$$$ and some previous position of $$$cur$$$ is $$$i$$$, lets say it is $$$cnt_{cur}$$$. We'll add this to the answer and also store $$$cur$$$ in a vector with contains all non-$$$divider$$$ numbers visited (if its visited multiple times its stored multiple times). I'll explain how to calculate $$$cnt_{cur}$$$ in the other case.

2. $$$cur$$$ $$$=$$$ $$$divider$$$ — Then we want to add all possible values which act as $$$i$$$ to their respective counts. Clearly each number in the vector we stored can act as $$$i$$$ if this position acts as $$$j$$$, so we just add 1 to $$$cnt_{x}$$$ for each $$$x$$$ in the vector.

Also, we have to consider the case where all 4 numbers are the $$$divider$$$, but this is simply $$$cnt_{divider} \choose 4 $$$.

Now since we're iterating over $$$n$$$ distinct numbers and iterating over the whole array in $$$O(n)$$$ each time, and operation 2 is clearly $$$O(n)$$$, it may appear as if the total complexity is $$$O(n^ 3)$$$. However we can observe that $$$cur$$$ $$$=$$$ $$$divider$$$ can only occur $$$n$$$ times over all iterations as each position has only 1 value. So operation 1 which takes $$$O(1)$$$ time is run $$$O(n ^ 2)$$$ times and operation 2 which has complexity $$$O(n)$$$ is run $$$O(n)$$$ times, so overall $$$O(n ^ 2)$$$ which easily passes.

My submission — 90967360

https://mirror.codeforces.com/contest/1400/submission/90950605

I iterated for i and k and maintain some arrays which mean:

lft[x]: how many x appears in the range [i+1,k-1]

rht[x]: how many x appears in the range [k+1,n]

cnt[x]: how many pairs of (x,x) with the first x in [i+1,k-1] and the second x in [k+1,n]

Apparently, (cnt[x] = lft[x] * rht[x] ) always hold but we can't iterate for x (which cause TLE). But note that with the same i, we move k from k to k+1 will cause only the change of cnt[a[k]] and cnt [a[k+1]], so cnt[] can be maintained with O(1) and the solution is O(n^2)

The solution is greedy. First, if s>w swap them and the number of sords with the number of axes. Make a for from 0 to x axes that you take where x is the maximum available given, check if it's possible to take that many, then add as much sords as possible, then add as much axes as possible to your friend bag then add as much sords as possible to your friends bag. That's it!

Link to my code: 90946553

After D

Why? It is just a basic brute force.