火柴排队

求让∑(ai​−bi​)2的值最小的最小操作次数。
首先想如何使∑(ai​−bi​)2最小，这个给两个数组排序就好了，这样的话相减后的平方和一定是最小的。
那么问题就剩求最小的操作次数了。
分析样例，排完序后数组中的值不那么重要了，需要的只是其中的大小关系，于是就考虑到了离散化。
离散化后，数组 a 以数组 b 的元素为序的情况下的逆序对就是需要的最小交换次数。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 500000 + 5, mod = 1e8 - 3;
int c[maxn];
int n;
struct node {
    int val, th;
    bool operator < (const node &k) const {
        return val < k.val;
    }
    bool operator >= (const node &k) const {
        return val >= k.val;
    }
} a[maxn], b[maxn];
int lowbit(int x) { return x & -x; }
void add(int i, int x)
{
    while(i <= n) {
        c[i] += x;
        i += lowbit(i);
    }
}
int que(int i)
{
    int ret = 0;
    while (i) {
        ret += c[i];
        i -= lowbit(i);
    }
    return ret;
}
int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i].val);
        a[i].th = i;
    }
    for (int i = 1; i <= n; i++) {
        scanf("%d", &b[i].val);
        b[i].th = i;
    }
    sort(a + 1, a + 1 + n);
    sort(b + 1, b + 1 + n);
    for (int i = 1; i <= n; i++) {
        a[a[i].th].val = i;
        b[b[i].th].val = i;
    }
    for (int i = 1; i <= n; i++) b[i].th = i;
    sort(b + 1, b + 1 + n);
    for (int i = 1; i <= n; i++) {
        int pos = lower_bound(b + 1, b + 1 + n, a[i]) - b;
        a[i].val = b[pos].th;
    }
    /* for (int i = 1; i <= n; i++) {
        cout << a[i].val << " ";
    } */
    int ans = 0;
    for (int i = 1; i <= n; i++) {
        add(a[i].val, 1);
        ans = (ans + i - que(a[i].val)) % mod;
    }
    cout << ans;
    ;
    return 0;
}

AC后去看题解，我的代码中有几个操作是O(N*LogN)的，但题解的操作直接将这些操作优化成了O(N)。
这是他们的代码：

for (int i = 1; i <= n; i++) {
        a[a[i].loc] = b[i].loc;//离散优化 
    }

我的:

for (int i = 1; i <= n; i++) {
        a[a[i].th].val = i;
        b[b[i].th].val = i;
    }
    for (int i = 1; i <= n; i++) b[i].th = i;
    sort(b + 1, b + 1 + n);
    for (int i = 1; i <= n; i++) {
        int pos = lower_bound(b + 1, b + 1 + n, a[i]) - b;
        a[i].val = b[pos].th;
    }

这两段代码运行后的结果是完全相同的，但是我的在时间复杂度上多了个LogN，在数据比较毒瘤的情况下，还是有可能被卡的。

分析一下，想要的最终的离散化结果就是，在数组 a 中第 i 个数在数组 b 中是第几个。
我们不同的代码之前的相同之处就是分别给 a 和 b 排了序，排序完后原有的值就不重要了，重要的是大小关系。
a 中的 1 和 b 中的 11 可以说是等价的了。
所以题解的代码和我的代码运行完结果是一样的。
我的代码有些画蛇添足，先将a 和 b对整数集进行了离散化，再用排序一遍，再用lower_bound找 a 中的元素在 b 中是第几个。
这样做不如题解的直接映射。

最后纪念一下这是我在洛谷第一道独立思考做出来的蓝题嘻嘻嘻