火柴排队（逆序对 + 离散化）

505. 火柴排队

原题链接

思路

如下是画图分析的一些过程

在这里贪心的思路是排序，然后两个数组都是从小到大那样对应的话最终的答案可达到最小
而我们只能交换相邻的火柴，故在这里先假设一个简化版本，即A有序，而只需要对B进行操作，可发现，其实就是再在求逆序对数量
有了简化版本思路，我们再对原数组进行处理，这里想到将其转化为简化版，也就是将原数组映射为排好序的1,2,3,…这样的数组，然后相应的也映射到B数组，随后就可以进行操作了
要注意的一点，数据过大，故先将a[], b[]数组进行离散化

离散化的话一般是从下标1开始的，故题目中最好也用下标从1开始

代码如下

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010, MOD = 99999997;
int n, a[N], b[N], c[N], p[N];  //这里的p数组可理解为临时数组，用来当作容器为其他数组服务
//c[]数组为映射数组

void work(int a[]) {
    for(int i = 1; i <= n; i++) p[i] = a[i];
    sort(p + 1, p + n + 1);
    for(int i = 1; i <= n; i++) a[i] = lower_bound(p + 1, p + n + 1, a[i]) - p;
}

int merge_sort(int l, int r) {
    if(l >= r)  return 0;
    int mid = l + r >> 1;
    //这里的分治区间别忘了累加res
    int res = (merge_sort(l, mid) + merge_sort(mid + 1, r) ) % MOD;
    int i = l, j = mid + 1, k = 0;
    while(i <= mid && j <= r) {
        if(b[i] <= b[j])    p[k++] = b[i++];
        else {
            p[k++] = b[j++];
            res = (res + mid - i + 1) % MOD;
        }
    }
    while(i <= mid) p[k++] = b[i++];
    while(j <= r) p[k++] = b[j++];
    for(int i = l, j = 0; i <= r; i++, j++) b[i] = p[j];
    return res;
}

int main() {
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
    for(int i = 1; i <= n; i++) scanf("%d", &b[i]);
    //首先，数据太大，进行数据的离散化（也是为了后期的映射对位）
    work(a), work(b);
    //然后，进行映射，将A数组映射为一个排好序的数组，B数组根据A数组数据也对应位置
    for(int i = 1; i <= n; i++) c[a[i]] = i;
    //对B的操作，在映射数组C[]中找b[i]的映射数据
    for(int i = 1; i <= n; i++) b[i] = c[b[i]];
    //最后，进行求最少交换次数（逆序对数量）
    int ans = merge_sort(1, n) % MOD;
    cout << ans;
    return 0;
}