Souvlaki VS. Kalamaki

Let the sorted version of the multiset be

$$b_1 \le b_2 \le \cdots \le b_n.$$

If Souvlaki wins, the final array must be exactly this sorted sequence of values.

The game processes adjacent edges from left to right. Round $i$ is the only time positions $i$ and $i+1$ can be swapped. After round $i$ ends, position $i$ will never be touched again. So the final array gets fixed one position at a time from left to right.

Now look at Kalamaki’s turns. He plays on even rounds:

$$2,4,6,\ldots$$

At an even round $i$, Kalamaki decides whether to swap positions $i$ and $i+1$. Since position $i$ becomes locked immediately after this, Souvlaki must be okay with both choices.

That means the two possible values Kalamaki can lock into position $i$ must both be valid. But the sorted target needs position $i$ to contain $b_i$. If those two values are different, Kalamaki can choose the wrong one. So the only safe case is when the two values are equal.

Therefore, in the sorted target, every Kalamaki-controlled boundary must have equal values:

$$b_2=b_3,\quad b_4=b_5,\quad b_6=b_7,\quad \ldots$$

This condition is also enough. If it holds, Souvlaki simply arranges the array in sorted order before the game starts. On every odd round, he skips. On every even round, Kalamaki is swapping two equal adjacent values, so the array does not change. Kalamaki gets to make moves, but they do absolutely nothing. Brutal, but fair.

If the condition fails for some even $i$, then $b_i<b_{i+1}$. When Kalamaki controls that boundary, Souvlaki would need position $i$ to become exactly $b_i$ no matter what Kalamaki chooses. That would require both candidate values to be $b_i$, meaning there would still be another $b_i$ after position $i$. But if $b_i<b_{i+1}$, there is no extra copy of $b_i$ after position $i$ in sorted order. Contradiction. So Souvlaki cannot guarantee a win.

Algorithm:

1. Sort the array.
2. Check every even 1-based index $i<n$: $2,4,6,\ldots$.
3. If $a_i=a_{i+1}$ for all of them, print YES; otherwise print NO.

In 0-based indexing, check indices (1,2), (3,4), (5,6), etc.

Complexity: $O(n\log n)$ per test case, easily fine for $n\le 100$.