【洛谷】P1966 火柴排队（配数学证明）

题目地址：

https://www.luogu.com.cn/problem/P1966

题目描述：
涵涵有两盒火柴，每盒装有$n$根火柴，每根火柴都有一个高度。现在将每盒中的火柴各自排成一列， 同一列火柴的高度互不相同， 两列火柴之间的距离定义为：$\sum (a_i-b_i{)}^2$其中$a_i$表示第一列火柴中第$i$个火柴的高度，$b_i$表示第二列火柴中第$i$个火柴的高度。每列火柴中相邻两根火柴的位置都可以交换，请你通过交换使得两列火柴之间的距离最小。请问得到这个最小的距离，最少需要交换多少次？如果这个数字太大，请输出这个最小交换次数对$10^8-3$取模的结果。

输入格式：
共三行，第一行包含一个整数$n$，表示每盒中火柴的数目。
第二行有$n$个整数，每两个整数之间用一个空格隔开，表示第一列火柴的高度。
第三行有$n$个整数，每两个整数之间用一个空格隔开，表示第二列火柴的高度。

输出格式：
一个整数，表示最少交换次数对$10^8-3$取模的结果。

数据范围：
对于$10\%$的数据， $1\le n\le 10$；
对于$30\%$的数据，$1\le n\le 100$；
对于$60\%$的数据，$1\le n\le 10^3$；
对于$100\%$的数据，$1\le n\le 10^5$，$0\le 0\le 火柴高度<2^{31}$。

题目大意转述为，给定两列相同个数的数字，满足$0<a_1<a_2<...<a_n$（这个假设需要先对第一个数组按大小排序，然后第二个数组也要跟着一起排），另有$n$个正数$b_1,...,b_n$，求$b$的一个排列使得$\sum (a_i-b_i{)}^2$最小，只允许对$b$相邻数字交换，返回从原顺序到此排列需要进行的交换次数。

先证明，当$b$单调增的时候上式子最小。用归纳法。当$n=2$时，设$0<b_1<b_2$，有$$\begin{gathered} (a_1-b_2{)}^2+(a_2-b_1{)}^2-(a_1-b_1{)}^2-(a_2-b_2{)}^2 \\ =(b_1-b_2)(2a_1-b_1-b_2)-(b_1-b_2)(2a_2-b_1-b_2) \\ =2(b_1-b_2)(a_1-a_2)>0 \end{gathered}$$成立。对于$n$，考虑$(1,2,...,n)$上的某个$n$元置换$\sigma$，我们试图证明使得$\sum (a_i-b_{\sigma (i)}{)}^2$最小的置换是恒等置换。如若不然，则必有逆序对，由于命题对$n=2$是成立的，所以我们交换那两个产生逆序对的$b_i$和$b_j$就得到了更大的和，矛盾。

现在回到原题，对于每个$a_i$，要确定$a_i$在$a$数组里的排名是多少，设为$k$，然后找到$b$里排名第$k$的数，要将其换到$i$这个位置，这样就能使得距离最小了。我们考虑将$a_i$映射为$i$，令$c[i]$是$b$中排名与$a_i$在$a$中排名一样的那个数的下标，我们只需要求$c$做多少次对换就可以变为单调递增的，结论是求$c$的逆序对个数（具体证明可以用冒泡排序来证，首先升序数组逆序对个数为$0$，而做一次对换逆序对个数最多减少$1$，所以次数大于等于逆序对个数；容易知道冒泡排序每次交换都可以使得逆序对个数减少$1$，所以下界能取到）。求逆序对个数可以用归并排序来做。

还有个小问题需要证明，即只操作一个序列是否能得到最小交换次数。答案是确实可以。可以对逆序对的个数做归纳，逆序对只有一个的时候显然正确。剩余证明不难。

代码如下：

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 1e5 + 10, MOD = 1e8 - 3;
int n;
struct Pair {
    int x, id;
    bool operator<(const Pair &p) const {
        return x <= p.x;
    }
} a[N], b[N];
int c[N], tmp[N];
int res;

void merge_sort(int l, int r) {
    if (l >= r) return;
    int mid = l + r >> 1;
    merge_sort(l, mid);
    merge_sort(mid + 1, r);

    int i = l, j = mid + 1, idx = l;
    while (i <= mid && j <= r) {
        if (c[i] <= c[j]) tmp[idx++] = c[i++];
        else {
            res = (res + mid - i + 1) % MOD;
            tmp[idx++] = c[j++];
        }
    }

    while (i <= mid) tmp[idx++] = c[i++];
    while (j <= r) tmp[idx++] = c[j++];
    for (int k = l; k <= r; k++) c[k] = tmp[k];
}

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {scanf("%d", &a[i].x); a[i].id = i;}
    for (int i = 1; i <= n; i++) {scanf("%d", &b[i].x); b[i].id = i;}

    sort(a + 1, a + 1 + n);
    sort(b + 1, b + 1 + n);

    for (int i = 1; i <= n; i++) c[a[i].id] = b[i].id;
    merge_sort(1, n);
    printf("%d\n", res);

    return 0;
}

时间复杂度$O(n\log n)$，空间$O(n)$。