To understand how many swaps are needed to balance the number of inversions in each subarray, we first need to understand how a swap changes the number of inversions in each subarray. In particular, we're interested in the quantity $\Delta = \text{# inversions in first half} - \text{# inversions in second half}$.

Call a swap between the $n$-th and $(n+1)$-st elements of the array a "central" swap. Any non-central swap either increases or decreases $\Delta$ by $1$. Furthermore, a central swap of the form $1,0 \to 0,1$ increases $\Delta$ by a fixed amount: $\text{# ones in array} - n$. And a central swap of the form $0,1 \to 1,0$ decreases $\Delta$ by the same amount.

Suppose that we use no central swaps. Then we need to perform at least $|\Delta|$ swaps. It turns out that this is sufficient: in the subarray with more inversions, we can always perform swaps to decrease the number of inversions.

Notice that any sequence of swaps can be interpreted as moving around the $1$s in the array. Any optimal sequence never swaps two $1$s, and the path traced out by each $1$ is monotonic. So if the sequence increases the number of $1$s in the first half by $t$ (some integer, possibly negative), then it's optimal to perform $|t|$ central swaps (all of them moving $1$s in the same direction).

So let's try $t = 0, 1, 2, \dots$ in order (the cases $t<0$ are similar). As $t$ increases, we push more and more $1$s from the first half of the subarray to the second half. Each push has three components:

1) non-central swaps in the first half, to move the $1$ to position $n$

2) non-central swaps in the second half, to make sure that there's a $0$ at position $n+1$

3) a single central swap moving the $1$ from position $n$ to the now-empty position $n+1$

Note that for a fixed $t$, these swaps are all necessary: we moved each $1$ as little as possible while still having $t$ central swaps.

We need to track $\Delta$ through each push. We use a two-pointers approach: one pointer in the first half of the array, pointing to the rightmost $1$. And one pointer in the second half of the array, pointing to the leftmost $0$. These pointers allow us to easily compute the number of non-central swaps forced by the push, and thus the change in $\Delta$. As we've shown above, the effect of the central swap is also straightforward.

Finally, suppose we know the value of $\Delta$ after $t$ central swaps (and the associated pushes). Then as in the $t = 0$ case, we need $|\Delta|$ more non-central swaps to balance the number of inversions (this is in addition to the "forced" swaps). As $t$ increases, we simply track the best number of swaps found so far.

Since each pointer is monotonic, the overall time complexity is $O(n)$.

This solution implements the above idea. It handles the $t < 0$ cases by viewing the sequence of swaps as moving the $0$s rather than moving the $1$s. This allows the above $t \geq 0$ logic to be reused.

#include <iostream> #include <algorithm> using namespace std; #define MAXN 100000 int N; int A[2*MAXN]; long long best; int ones; long long llabs(long long x) { if(x<0) return -x; return x; } long long countInversions(int a,int b) { long long t = 0; int n1 = 0; for(int i=a;i<=b;i++) { if(A[i]==1) n1++; else t += n1; } return t; } int tp, sgn; void solve() { long long inv0 = countInversions(0,N-1); long long inv1 = countInversions(N,2*N-1); long long dif = inv0 - inv1; best = min(best, llabs(dif)); int n1 = 0; int j = N; int displaced = 0; long long cost = 0; for(int i=N-1;i>=0;i--) if(A[i]==tp) { dif -= sgn*(N-1-i), cost += N-1-i; dif += sgn*(ones - N), cost++; dif += sgn*n1, cost += n1; dif += sgn*displaced, cost += displaced; n1++; if(n1 + displaced > N) return; while(n1 + displaced > j-N) { if(A[j]==1-tp) j++; else if(j==2*N-1) return; else { dif += sgn*(N + n1 + displaced - j), cost += N + n1 + displaced - j; displaced++; j++; } } best = min(best, cost+llabs(dif)); } } int main() { cin >> N; for(int i=0;i<2*N;i++) { cin >> A[i]; ones += A[i]; } best = MAXN*((long long)MAXN); tp = 1, sgn = 1; solve(); tp = 0, sgn = -1; solve(); cout << best << '\n'; }