1.归并排序

归并排序的步骤如下：

①枚举中点，将区间分为左右两段；

②对左右两段区间分别排序；

        这个过程以递归的方式进行。

③合并两段区间。

        是一个模拟的过程。用两个指针分别指向左右区间，判断当前哪个数小，将小的数合并进总区间，指针后移。当指针移到某个区间的末尾，则将另一个区间的剩余部分直接接到总区间后面。

代码模板如下：

#include<iostream>
using namespace std;
const int N=1e5+10;
int n,a[N],tmp[N];
void merge_sort(int a[],int l,int r)
{
    if(l>=r) return;
    int mid=(l+r)>>1;
    merge_sort(a,l,mid);
    merge_sort(a,mid+1,r);
    int i=l,j=mid+1,k=0;
    while(i<=mid&&j<=r)
    {
        if(a[j]<=a[i]) tmp[k++]=a[j++];
        else tmp[k++]=a[i++];
    }
    while(i<=mid) tmp[k++]=a[i++];
    while(j<=r) tmp[k++]=a[j++];
    for(int i=l,j=0;i<=r;i++,j++) a[i]=tmp[j];
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    merge_sort(a,1,n);
    for(int i=1;i<=n;i++) printf("%d ",a[i]);
}

2.求逆序对数量

归并排序一个很重要的作用就是用来求数组中的逆序对数量。

在归并排序过程中，当我们发现ai>aj时，所有[ai,mid]区间内的数都可以和aj构成逆序对，我们把这些数加起来，就能计算出所有的逆序对数量。

#include<iostream>
using namespace std;
const int N=1e5+10;
typedef long long ll;
int n,a[N],tmp[N];

ll merge_sort(int a[],int l,int r)
{
    if(l>=r) return 0;
    int mid=(l+r)>>1;
    ll res=merge_sort(a,l,mid)+merge_sort(a,mid+1,r);
    int k=0,i=l,j=mid+1;
    while(i<=mid&&j<=r)
    {
        if(a[i]>a[j])
        {
            res+=(mid-i+1);
            tmp[k++]=a[j++];
        }
        else tmp[k++]=a[i++];
    }
    while(i<=mid) tmp[k++]=a[i++];
    while(j<=r) tmp[k++]=a[j++];
    for(int i=l,j=0;i<=r;i++,j++) a[i]=tmp[j];
    return res;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    ll res=merge_sort(a,1,n);
    printf("%lld",res);
}

3.小朋友排队

我们可以知道，通过交换，我们每次可以最多减少1个逆序对，假设逆序对数量为k，要完成排序，我们交换的总次数最少是k次，而这个最少次数是可以达到的（在冒泡排序中就可以达到），而且在达到这个次数时，我们的交换方案是恒定的（必须按照冒泡排序的方式）。

对于某个小朋友，如果他前面有k1个比他高的小朋友，后面有k2个比他低的小朋友，要使最后小朋友的身高变为从小到大排列，那么这个小朋友至少要被交换k1+k2次。

而k1+k2的值，我们可以借助归并排序求出。

当a[i]>a[j]时，[i,mid]范围内的数都大于a[j]，对于a[j]来说，有mid-i+1个逆序对，即a[j]的k1=mid-i+1；

当a[j]>=a[i]时，[mid+1,j-1]范围内的数都小于a[i]，对于a[i]来说，有j-mid-1个逆序对，即a[i]的k2=j-mid-1。

#include<iostream>
using namespace std;
const int N=1e5+10;
typedef pair<int,int> PII;
typedef long long ll;
#define x first
#define y second
int n;
PII a[N],tmp[N];
ll cnt[N];
void merge_sort(PII a[],int l,int r)
{
    if(l>=r) return;
    int mid=(l+r)>>1;
    merge_sort(a,l,mid);
    merge_sort(a,mid+1,r);
    int k=0,i=l,j=mid+1;
    while(i<=mid&&j<=r)
    {
        if(a[i].y>a[j].y) 
        {
            cnt[a[j].x]+=(mid-i+1);
            tmp[k++]=a[j++];
        }
        else
        {
            cnt[a[i].x]+=(j-mid-1);
            tmp[k++]=a[i++];
        }
    }
    while(i<=mid) 
    {
        cnt[a[i].x]+=(r-mid);
        tmp[k++]=a[i++];
    }
    while(j<=r) 
    {
        tmp[k++]=a[j++];
    }
    for(int i=l,j=0;i<=r;i++,j++) a[i]=tmp[j];
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) 
    {
        a[i].x=i;
        scanf("%d",&a[i].y);
    }
    merge_sort(a,1,n);
    ll res=0;
    for(int i=1;i<=n;i++) res+=(cnt[i]+1)*cnt[i]/2;
    printf("%lld",res);
}

4.火柴排队

505. 火柴排队 - AcWing题库

首先需要一点点贪心，我们可以证明出，当a、b都单调排列时，得到的距离是最小的。证明的过程是反证法，我们假设a(i)<a(i+1),b(i)>b(i+1),与a(i)<a(i+1),b(i)<b(i+1)的情况进行比较就可以很容易证明。

接下来，我们可以将问题简化，假设a数组是单调递增的，那么此时的最小交换次数就等于b的逆序对数量。我自己在这里就犯了一个小错误，到这一步，就想当然地认为最后的结果就等于b数组逆序对数量-a数组逆序对数量。其实不是，逆序对数量相等的两个数组并不是完全相同的。

我们继续往下思考。其实，我们只需要保证a、b数组中按照从小到大排序，处于一个位置的数一一对应就好了。由此，我们可以将a数组的1~n位数字映射成1~n，并将b数组中的数字按照这个映射规则映射一遍，此时情况就变成了我们上一步思考的简化情况：a数组升序排列。而b数组的数，因为使用和a数组相同的字典也映射了一遍，因此可以反映出实际中a、b数组中应对应的数的位置差距。

在映射时感觉有一个小bug，我只用a中的元素构建了映射表，但是，如果b中出现了a中没有出现的元素，我的映射会出现问题。

#include<iostream>
#include<unordered_map>
#include<algorithm>
using namespace std;
const int N=1e5+10;
const int mod=99999997;
typedef long long ll;
int a[N],b[N],tmp[N],c[2*N];
int n;
unordered_map<int,int> ha;
ll merge_sort(int a[],int l,int r)
{
    if(l>=r) return 0;
    int mid=(l+r)>>1;
    ll res=merge_sort(a,l,mid)+merge_sort(a,mid+1,r);
    res%=mod;
    int k=0,i=l,j=mid+1;
    while(i<=mid&&j<=r)
    {
        if(a[i]>a[j])
        {
            res+=mid-i+1;
            tmp[k++]=a[j++];
        }
        else tmp[k++]=a[i++];
    }
    while(i<=mid) 
    {
        tmp[k++]=a[i++];
    }
    while(j<=r) tmp[k++]=a[j++];
    for(int i=l,j=0;i<=r;i++,j++) a[i]=tmp[j];
    return res%mod;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(int j=1;j<=n;j++) scanf("%d",&b[j]);
    int k=1;
    
    for(int i=1;i<=n;i++)
    {
        if(ha.find(a[i])==ha.end()) ha.insert({a[i],k++});
    }
    
    for(int i=1;i<=n;i++) b[i]=ha[b[i]];
    ll k2=merge_sort(b,1,n);
    printf("%lld",k2);
}