[NOIP2013 提高组] 火柴排队

涵涵有两盒火柴，每盒装有 n 根火柴，每根火柴都有一个高度。

现在将每盒中的火柴各自排成一列，同一列火柴的高度互不相同，两列火柴之间的距离定义为：

其中 ai 表示第一列火柴中第 i 个火柴的高度，bi 表示第二列火柴中第 i 个火柴的高度。 

每列火柴中相邻两根火柴的位置都可以交换，请你通过交换使得两列火柴之间的距离最小。

请问得到这个最小的距离，最少需要交换多少次？

如果这个数字太大，请输出这个最小交换次数对 99,999,99799,999,997 取模的结果。

输入格式

共三行，第一行包含一个整数 n，表示每盒中火柴的数目。 

第二行有 n 个整数，每两个整数之间用一个空格隔开，表示第一列火柴的高度。

第三行有 n 个整数，每两个整数之间用一个空格隔开，表示第二列火柴的高度。

输出格式

输出共一行，包含一个整数，表示最少交换次数对 99,999,99799,999,997 取模的结果。

数据范围

1≤n≤105,
0≤火柴高度≤231−10≤火柴高度≤231−1

输入样例：

4
2 3 1 4
3 2 1 4

输出样例：

1

首先分析题目，肯定是要往逆序对这个方向上去靠，求逆序对可以用归并排序或者树状数组。

我们可以发现本题对于火柴的移动，可以简化成：完全固定一边，只移动一边。接着我们只要计算，将另外一遍移动到对应位置需要几次。再通过离散化操作和哈希索引，将数组转换成用归并排序求逆序对的模板，即可完成本题。

1. 给定两个数组 a 和 b，分别代表两列火柴的高度。

   a: 2 3 1 4   b: 3 2 1 4

2. 首先，我们可以通过数组 a 得到数组 p。数组 p 的作用是根据数组 a 的大小，构造一个新的数组，使得数组 p 中的值越小，对应的数组 a 中的值越小。

   p: 1 2 0 3

3. 然后，我们继续对数组 b 进行同样的处理，得到新的数组 c。数组 c 的作用是构造一个映射关系，使得数组 a 变成有序的，并且通过这个关系来对数组 b 确定顺序。

   c: 2 0 1 3

4. 构造完数组 c 后，我们可以通过数组 c 来对数组 b 进行映射，从而得到有序的数组 b。

   b: 0 2 1 3

5. 接下来，我们可以对数组 b 进行归并排序，统计其中的逆序对。逆序对的数量表示需要交换的次数，从而得到最小的交换次数。

#include <iostream>
#include <algorithm>
#include <unordered_map>

using namespace std;

typedef long long ll;

const int N = 1e5 + 10, mod = 99999997;

int n;
int top[N], bom[N], tem[N];
unordered_map<int, int>th, bh;
int en[N];
ll 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 j = l, i = mid + 1, k = 0;
    while (j <= mid && i <= r) {
        if (en[j] <= en[i]) tem[k ++ ] = en[j ++ ];
        else {
            tem[k ++] = en[i ++ ];
            res = (res + mid - j + 1) % mod;
        }
    }
    while (j <= mid) tem[k ++ ] = en[j ++ ];
    while (i <= r) tem[k ++ ] = en[i ++ ];
    for (int i = 0, j = l; j <= r; j ++ , i ++ ) en[j] = tem[i];
}


void output(int a[]) {
    for (int i = 0; i < n; i ++ ) cout << a[i] << ' ';
    cout << endl;
}

int main() {
    cin >> n;
    for (int i = 0; i < n; i ++ ) {
        cin >> top[i];
        th[top[i]] = i;
    }
    
    for (int i = 0; i < n; i ++ ) {
        cin >> bom[i];
        bh[bom[i]] = i;
    }
    sort(top, top + n);
    sort(bom, bom + n);
    int gjb[N], gjt[N];
    for (int i = 0; i < n; i ++ ) gjb[i] = bh[bom[i]];
    for (int i = 0; i < n; i ++ ) gjt[i] = th[top[i]];
    unordered_map<int, int>hiem;
    for (int i = 0; i < n; i ++ ) hiem[gjb[i]] = gjt[i];

    sort(gjb, gjb + n);
    for (int i = 0; i < n; i ++ ) en[i] = hiem[gjb[i]];
    merge_sort(0, n - 1);
    cout << res;
}