ball

As a watcher , I always watch you comment fast (～￣▽￣)～

As a singer, I released a new song very fast.

I think so.

I'm also a Ronaldo fan, you are invited to participate!

That one guy(I'm not assuming your gender) who takes the payment and dips:

I think it's a Messi contest!

but you can participate even if you are not a messi fan!

Good luck to everyone for this contest!

Searching for Ronaldo in comments great at least one identified the presence of suiiiiii!!!!

greatest of all time

Vai tell me this contest won't be a mathforces contest :'(

please check if this helps — Everything about Codeforces scoring system

We all know you are a cheater (✿◠‿◠)

Yeah What was your approach after that? I realised that if there are no odd occurences than we can only split the even occurences among two if the number of even occurences have the same parity as n. If not than there would be a even occurence we can't split and so my code became like this:

if you found an odd occurence add 1 to ans if you found an even occurence add 2 to ans

if there are no odd occurence than check whether parity of number of even occurences is same as n. If it is than subtract 2 from ans.

Finally output ans.

This was my solution for b but I could not solve C can you tell me how you solved it? I was able to deduce that if k is even than we simply calculate the maximum subarray sum using kadane's but when k is odd than we can change 1 element of a[i] to a[i] + b[i]. But how do you go about doing this optimally in o(n) or in o(nlogn). I was stuck here...

convert both strings into the zero string, reverse the order of instructions to get the 2nd string.

Of course it can be solved in O(n). But $$$n\leq 100$$$ makes it easier to implement.

I also solved D in O(n). You can always use 3 bits to flip the first one in at most 2 operations. This way you can adjust all bits, but the last 2. For the last two I did a BFS over the last 4 bits of the string. n being bigger or equal than 4 seemed to hint that this was the wanted approach. (I have no proof though, that the last 4 bits are enough or that it does not use too many operations for the last 2 bits)

Yup, there's a few solutions. My solution first brute-forces the $$$n = 4$$$ case. After that, I go from left to right in both strings (to the point $$$i = n-4$$$) and if they differ, fix the difference by doing small local changes — either a length $$$2$$$ change if $$$s_i = s_{i+1}$$$, a length $$$3$$$ change if $$$s_i = s_{i+2} \neq s_{i+1}$$$ or a length $$$2$$$ change on $$$(i+1, i+2)$$$ followed by a length $$$3$$$ on $$$(i, i+1, i+2)$$$ if $$$s_i \neq s_{i+1} = s_{i+2}$$$. After that, the strings are identical besides the last $$$4$$$ positions, the solution for which I get from my initial brute-force search and shift the indices.

The reason it works is that I make at most $$$2$$$ operations for each index except the last $$$4$$$, and I verified that my brute-force approach takes at most $$$8$$$ operations on the $$$n = 4$$$ case, so I get a total of at most $$$2(n-4) + 8$$$ operations as desired.

it was ultimately how to divide elements having even frequency ... because however you divide odd frequency it can only contribute +1 to the answer

Numbers having ODD freq. will always contribute at max +1 to the final score, whereas EVEN frequency either contribute +2 or +0 only. Also, we can split any odd number = A + B, where |A-B| = 1, eg. 7 = 4 + 3. Also, these "1" are always even in numbers (as, sum of freq = 2*n, i.e. EVEN) so they can be distributed easily, to either set 'P' or set 'Q'. Now, for even to contribute +2, either even/2 = odd, or leftover evens, i.e. those evens where, even/2 = even number, can contribute +2 only if either even no. of such even numbers are present or either atleast we have 2 or more +1 deviation that we got from odd frequency. else one +2 won't be considered into our answer; Though a bit of casework but this is what i wrote in my code, if anyone have a simpler solution do share :)

1. You will take all the odds. There is no point of leaving an odd freq. Contribution of odd is 1.
2. You will leave at most 1 even. This depends of the parity of n and even freq. The parity should either be same or there should at least be 1 odd freq to fill the parity gap. Even contributes 2 (odd+odd = even)

Final answer: ans = odd + ((n - even) % 2 == 0 || odd > 0 ? even : even - 1) * 2;

How to solve E?

is similar to this same idea https://mirror.codeforces.com/problemset/problem/1593/G but the use here is brackets, to make "string flipping segments"

。

what was the checker not checking?

lol

Similar for me, I solve C in less than 15 minutes but for b it took 1+ hour

same like C is way easier, I got the idea instantly after reading C, while B cooked me so hard

what? u don't like writing

vector<map<pair<int,int>,vector<pair<int,int>>>>

?

The implementation wasn't that bad frankly, especially since it's just duplicate code in a lot of places

The reversal solution starting from t is genius! Couldn't think about it :(.

You should be able to submit after the system tests for that contests are over.