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);
}
