you'll be nutella soon :p

Will mere mortals survive this?

For such a round, there would be less to worry about, because when it gets too hard for you, you won't submit any solution and it becomes unrated eventually.

Even the strongest of rounds always has a weakness.

lol then you're not that random guy I wish

Peace ✌️

Does this mean that problems won't be sorted by difficulty?

Maradona > Messi

"The round will be rated for both divisions. (At least that's what I've been told!)" :)

He can not participate in this contest because of He is coordinator in this round.

and is it rated?

We thought Div2-D would be much easier than it turned out to be. Sorry for that. :(

I always expect such an unbalanced round from red coders.

Too true. Hopefully I can recover my rating in next contest.

The ones who could solve it were busy doing Div1

Let $$$x, y, z$$$ be the current length of religions. Consider dp[i][j][k] = Minimum index of string s such that first x characters of first religion, first y characters of second religion and first z characters of third religion form disjoint subsequence in s[1..idx].

with this Each query can be answered in O(250*250)

We all are with you.

What's the way to be a tester for Div2 ?

I think that before the round all type of colors should test it ;

2250 looks fair enough, but it would be great to have something to solve in between C and D

I feel people with various ratings should test the problems so as to get an idea on the difficulty. For someone with such high rating, it is obvious for him to feel D easy, hence we should not be blaming the setter. Hence the difficulty thing can only be solved if it is tested by the corresponding color.

P:S- Just an opinion

The idea of making Div2C = Div1A did wonders when the Div1 cutoff was 1700 — the average skill of Div1 was much lower back then, so it's OK for Div1B to be easy. Right now it's very hard to set a balanced problemset for both divisions this way. The last 5+ Div1+Div2 rounds had either (or both) of them consist of 6 problems, so that the average blue will solve 3-4.

This round's Div1B was not imbalanced, it's just that Div2 people are too used to have 6 problems, therefore Div1B is supposed to be Div2E. I think it'd be better to just make every Div2 contests have 6 problems, and share 3 problems with Div1 (or even 2, hardly anyone solves Div1C anyway).

In my opinion, the score gap between two problems should be bigger when the score itself is bigger.

For example, having 500 — 1250 difficulties isn't same as having 1500 — 2250. It doesn't take too much time for a 2250 problem become around 1500 points, while a 1250 problem never becomes less than 500 (unless someone makes a lot of WA submissions). So if one thinks that D1A — D1B should be 500 — 1250, it's likely that D2C — D2D would be more appropriate for 1500 — 3000 or something. With this perspective, we're definitely missing one or two problems between them.

Also the reason the number of people solved D1A — D1B looks balanced is just because most people in Div. 1 should be good enough to solve 4 problems for Div. 2, and it rather seems that D1B was quite hard for this round because only around half of people in Div. 1 could solve B, which means the other half would've solved only 3 problems if they were Div. 2.

I looking forward to your Div.2 and Div.3.

You are missing a wall.

Let $$$dp(i, j, k)$$$ be shortest prefix of long string such that it contains prefixes of lengths $$$i, j, k$$$ of three strings as disjoint subsequences. $$$dp(i, j, k)$$$ can be easily calculated through $$$dp(i - 1, j, k), dp(i, j - 1, k), dp(i, j, k - 1)$$$ by taking prefix of length $$$dp(i - 1, j, k)$$$ and finding first character after prefix in the long string that is equal to $$$i$$$-th character of first short string. So in each query you have to calculate up to $$$250 \cdot 250$$$ states of dp. I came up with this solution quite quickly but had hard time coding and debugging, so I'm really curious how could someone come up with the solution and code it in around 15 minutes.

Let DP[a][b][c] indicate the shortest prefix of the string we can use to have prefixes of lengths a, b and c from the religions as distinct substrings of it. The DP is trivial to update with DP[a][b][c] = min(DP[a][b][c], next_occ(religion_a[a-1], DP[a-1][b][c])), and similarly for b and c. The DP takes 250^3 memory which fits.

If we calculate the DP again at every step, we use 250^3 * 1000 time which is too much, but notably the only states that change are those where the last character of the changing string appears (so if we add a character to the end of religion a, then only DP states of the form DP[len(religion_a)][b][c] change), and therefore we only have to do 250^2 work every update. 250^2 * 1000 is fast enough.

It's solved with a somewhat simple DP, but the implementation is kinda hard.

D is easy in my opinion

If you look at the Div1 contest though, 50% of the people who solved Div2 C also solved Div2 D. So I would think the problems themselves weren't that imbalanced.

You spend 2 first, if you dont get prime using 1.

One can see that if the number of twos is 0 or the number of ones is 0 we know the answer. Else, we have at least one of both. Then we use 2 at the first position and 1 at the second. Then just use all the Twos and then all the ones, cause all the primes greater then 3 are odd, so we use 2 to reach them!