## Editorial for Cute String Merging

**only**when stuck, and

**not to copy-paste code from it**. Please be respectful to the problem author and editorialist.

**Submitting an official solution before solving the problem yourself is a bannable offence.**

Author:

#### Subtask 1

We can use dynamic programming to solve this subtask.

Let whether the substring can be merged into the letter . The transition is pretty simple: we just check if we can merge two 'halves' of the string into our desired letter, with the base case being a substring of length .

Then, let the minimum number of characters we can merge the prefix into. In this case, we no longer perform merge operations and instead use our precomputed values of . Formally, .

The final answer is .

**Time complexity:** per test case.

#### Subtask 2

One thing you may notice after trying the merging process on some strings is that is you can reduce it to or characters almost every time. In fact, this is a very useful observation:

Let's denote our current string after some number of merges (possibly ) as . We'll assume that and contains at least types of characters.

We can show that if these constraints are satisfied, we can always reduce by character while making sure that it contains at least types of characters.

At every step, we just need to merge an index such that and the frequency of either (or both) and is more than . We can show that such an index will always exist through the following:

- At least one character (
`a`

,`b`

, or`c`

) will have a frequency by the pigeonhole principle as . We'll denote this character as . - As there are at least distinct types of characters and has positive frequency, there must exist an adjacent pair of characters in such that exactly one of the characters is .

Thus, if our initial string contains at least types of characters, we can always reduce it to a string of length with at least types of characters, which can then be further reduced to a string of size (and then possibly further). This means that given the initial string, the only possible answers are , , and .

For now, you can just assume that applying this greedy method is always optimal without showing how it distinguishes between cases where the answer is and where the answer is . The proof for this will be in the solution for the final subtask.

To pass this subtask, we can just simulate the merges, which has a time complexity of .

**Time complexity:** per test case.

#### Subtask 3

*This solution builds on the proof from the second subtask.*

Here's something interesting: every time a merge operation occurs, the frequency of every character changes by (the characters merged change by , while the new character changes by ). This means that the parity of the frequency of every character will flip on a merge operation.

Now consider a string of length that contains at least distinct characters, but will result in an answer of : the only case where this happens is if every character has frequency . Furthermore, this is also the only string of length where the frequency of every character has the same parity.

Next, recall that a merge operation changes the parity of every frequency, meaning that if the initial string has the same parity of frequency for each character, it will still retain this property after the merge (and vice versa). This means that all initial strings with the property of the frequency of each character having the same parity can only merge into a string of length that will result in an answer of , and if the frequency of any character has a different parity, this state will never be reached allowing the to reduce to length .

Lastly, as all you need to compute the answer is the frequency of every character, we can solve the problem in linear time.

**Time complexity:** per test case.

## Comments