If the given *n* is odd the answer is 0, because the perimeter of any rectangle is always even number.

If *n* is even the number of rectangles which can be construct equals to *n* / 4. If *n* is divisible by 4 we will count the square, which are deprecated, because we need to subtract 1 from the answer.

Asymptotic behavior — *O*(1).

At first let's find the minimum in the given array and store it in the variable *minimum*. It is easy to understand, that we always can paint *n* * *minimum* squares. So we need to find such a minimum in the array before which staying the most number of elements, which more than the minimum. In the other words we need to find 2 minimums in the array which are farthest from each other (do not forget about cyclical of the array). If there is only one minumum we need to start paint from the color which stay in the array exactly after the minimum (do not forget about cyclical of the array too). It can be done with help of iterations from the left to the right. We need to store the position of the nearest minimum in the variable and update her and the answer when we meet the element which equals to minimum.

Asymptotic behavior — *O*(*n*), where *n* — the number of different colors.

Let's build the answer recursively. For *k* = 0 the answer is - 1 or + 1. Let we want to build the answer for some *k* > 0. At first let's build the answer for *k* - 1. As the answer for *k* let's take four copies of answer for *k* - 1 with inverting of values in last one. So we have some fractal with 2 × 2 base: 00, 01. Let's prove the correctness of such building by induction. Consider two vector from the top (down) half: they have zero scalar product in the left half and in the right, so the total scalar product is also equals to zero. Consider a vector from the top half and from the down: their scalar products in the left and the right halfs differs only in sign, so the total scalar product is also zero.

Note the answer is also is a matrix with element *i*, *j* equals to \texttt{+} if the number of one bits in number *i*|*j* is even.

Complexity *O*((2^{k})^{2}).

At first let's unite all segments which are in same verticals or horizontals. Now the answer to the problem is the sum of lengths of all segments subtract the number of intersections. Let's count the number of intersections. For this let's use the horizontal scan-line from the top to the bottom (is can be done with help of events — vertical segment is open, vertical segment is close and hadle horizontal segment) and in some data structure store the set of *x*-coordinates of the open segments. For example we can use Fenwick tree with precompression of the coordinates. Now for current horizontal segment we need to take the number of the opened vertical segmetns with value *x* in the range *x*_{1}, *x*_{2}, where *x* — vertical where the vertical segment are locating and *x*_{1}, *x*_{2} — the *x*-coordinates of the current horizontal segment.

Asymptotic behavior: *O*(*nlogn*).

Consider slow solution: for operations of the first type reassign all letters, for operations of the second type let's iterate over the symbols in *s* from left to right and maintain the pointer to the current position in alphabet permutation. Let's move the pointer cyclically in permutation until finding the current symbol from *s*. And move it one more time after that. Easy to see that the answer is one plus the number of cyclic movements. Actually the answer is also the number of pairs of adjacent symbols in *s* that the first one is not righter than the second one in permutation. So the answer depends only on values of *cnt*_{ij} —- the number of adjacent symbols *i* and *j*.

To make solution faster let's maintain the segment tree with matrix *cnt* in each node. Also we need to store in vertex the symbol in the left end of segment and in the right end. To merge two vertices in the segment tree we should simply add the values in the left and in the right sons in the tree, and update the value for the right end of the left segment and the left end of the right segment.

Complexity: *O*(*nk*^{2} + *mk*^{2}*logn*).