798A - Mike and palindrome

Let cnt be the number of such that s_i ≠ s_{n - i + 1}.

If cnt ≥ 2 then the answer is NO since we must change more than 1 character.

If cnt = 1 then the answer is YES.

If cnt = 0 and n is odd answer is YES since we can change the character in the middle, otherwise if n is even the answer is NO because we must change at least one character.

Complexity is O(|s|).

Solution: Link

798B - Mike and strings

First of all, you must notice that the operation of removing the first character and appending it to the left is equivalent to cyclically shifting the string one position to the left.

Let's denote by dp_i, j the smallest number of operations for making the first i strings equal to string s_i moved j times.

Let f(i, j) be the the string s_i moved j times,then .

The answer is min(dp_n, 0, dp_n, 1, ..., dp_{n, |sn| - 1}).

The complexity is O(|S|³ × n).

Solution: Link

798C - Mike and gcd problem

First of all, the answer is always YES.

If then the answer is 0.

Now suppose that the gcd of the sequence is 1. After we perform one operation on a_i and a_i + 1, the new gcd d must satisfy d|a_i - a_i + 1 and d|a_i + a_i + 1 d|2a_i and d|2a_i + 1. Similarly, because d is the gcd of the new sequence, it must satisfy d|a_j, j ≠ i, i + 1.

Using the above observations we can conclude that , so the gcd of the sequence can become at most 2 times bigger after an operation. This means that in order to make the gcd of the sequence bigger than 1 we need to make all numbers even. Now the problem is reduced to the following problem:

Given a sequence v₁, v₂, ... , v_n of zero or one,in one move we can change numbers v_i, v_i + 1 with 2 numbers equal to . Find the minimal number of moves to make the whole sequence equal to 0.

It can be proved that it is optimal to solve the task for consecutive ones independently so we divide the array into the minimal number of subarrays full of ones, if their lengths are s₁, s₂, ... , s_t,the answer is .

Complexity is .

Solution: Link

798D - Mike and distribution

In the beginning, it's quite easy to notice that the condition " 2·(a_p1 + ... + a_pk) is greater than the sum of all elements in A " is equivalent to " a_p1 + ... + a_pk is greater than the sum of the remaining elements in A ".

Now, let's store an array of indices C with C_i = i and then sort it in decreasing order according to array A, that is we must have A_Ci ≥ A_Ci + 1.

Our answer will always have size . First suppose that N is odd. Add the first index to our set, that is make p₁ = C₁. Now, for the remaining elements, we will consider them consecutively in pairs. Suppose we are at the moment inspecting A_C2k and A_C2k + 1. If B_C2k ≥ B_C2k + 1 we make p_k + 1 = C_2k, else we make p_k + 1 = C_2k + 1.

Why does this subset work? Well, it satisfies the condition for B because each time for consecutive non-intersecting pairs of elements we select the bigger one, and we also add B_C1 to the set, so in the end the sum of the selected elements will be bigger than the sum of the remaining ones.

It also satisfies the condition for A, because A_p1 is equal or greater than the complement element of p₂ (that is — the index which we could've selected instead of p₂ from the above procedure — if we selected C_2k then it would be C_2k + 1 and vice-versa). Similarly A_p2 is greater than the complement of p₃ and so on. In the end we also add the last element from the last pair and this makes the sum of the chosen subset strictly bigger than the sum of the remaining elements.

The case when N is even can be done exactly the same as when N is odd, we just pick the last remaining index in the end.

The complexity is .

Solution: Link

798E - Mike and code of a permutation

The solution bellow needs some fixes. The original author currently doesn't have access to electricity and internet, he'll update it as soon as possible. To get a gist of the idea, check the solution.

Let's consider a_i = n + 1 instead of a_i =  - 1. Let's also define the sequence b, where b_i = j such that a_j = i or b_i = n + 1 if there is no such j. Lets make a directed graph with vertices be the indices of the permutation p with edges of type (a, b) representing that p_a < p_b. If we topologically sort this graph then we can come up with a possible permutation: if S is the topologically sorted graph then we can assign to p_Si number i (in other words p_Si = i).

But how we can find the edges? First of all there are edges of the form (b_i, i) if b_i ≠ n + 1 .For a vertex i he visited all the unmarked vertices j (1 ≤ j < a_i, j ≠ i) and you know for sure that for all these j,p_j < p_i. But how we can check if j was already marked? The vertex j will become marked after turn of vertex b_j or will never become unmarked if b_j = n + 1. So there is a direct edge from i to j if j = a_i or 1 ≤ j < a_i, j ≠ i and b_j > i.

The main problem is to extract j for a given i in a sub-quadratic time,the solution is segment tree and is based on the fact that each time we want to extract vertex j from all non-visited edges (1 ≤ j < a_i,j ≠ i) with maximal b_j,if b_j < i then there aren't remaining edges.

Complexity and memory are and O(N).

Solution: Link