目录
1、归并排序（模板）
给定你一个长度为 n 的整数数列。
请你使用归并排序对这个数列按照从小到大进行排序。
并将排好序的数列按顺序输出。
输入格式
输入共两行，第一行包含整数 n。
第二行包含 n 个整数（所有整数均在 1∼1e9 范围内），表示整个数列。
输出格式
输出共一行，包含 n 个整数，表示排好序的数列。
数据范围
1≤n≤100000
输入样例：
5
3 1 2 4 5
输出样例：
1 2 3 4 5思路：
归并排序的模板，运用了分治的思想，进入函数后递归调用，分别处理左右两边的子数组，最后再合并
代码：
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int q[N],tmp[N];
void mergesort(int q[],int l,int r)
{
if(r<=l)return;
int mid=(l+r)>>1;
mergesort(q,l,mid);mergesort(q,mid+1,r);
int k=0,i=l,j=mid+1;
while(i<=mid && j<=r)
{
if(q[i]<=q[j])tmp[k++]=q[j++];
else tmp[k++]=q[i++];
}
while(i<=mid)
{
tmp[k++]=q[i++];
}
while(j<=r)
{
tmp[k++]=q[j++];
}
//cout<<"yes"<<endl;
for(int i=l,j=0;i<=r;i++,j++)
{
//cout<<q[i]<<endl;
q[i]=tmp[j];//q不一定是从0开始的（但一定是从l），tmp一定是从0开始的
}
}
int main()
{
int n;
cin>>n;
for(int i=0;i<n;i++)
{
scanf("%d",&q[i]);
}
mergesort(q,0,n-1);
for(int i=n-1;i>=0;i--)printf("%d ",q[i]);
return 0;
}2、逆序对的数量（模板）
给定一个长度为 n 的整数数列，请你计算数列中的逆序对的数量。
逆序对的定义如下：对于数列的第 i 个和第 j 个元素，如果满足 i<j 且 a[i]>a[j]，则其为一个逆序对；否则不是。
输入格式
第一行包含整数 n，表示数列的长度。
第二行包含 n 个整数，表示整个数列。
输出格式
输出一个整数，表示逆序对的个数。
数据范围
1≤n≤100000
数列中的元素的取值范围 [1,109]
输入样例：
6
2 3 4 5 6 1
输出样例：
5思路：
在上面归并排序的基础上增加一个变量，维护 逆序对 就可以
代码：
#include<bits/stdc++.h>
using namespace std;
const int N =1e5+5;
int q[N],tmp[N];
typedef long long LL;
LL mergesort(int q[],int l,int r)
{
if(r<=l)return 0;
LL res=0;
int mid=(l+r)>>1;
res+=mergesort(q,l,mid)+mergesort(q,mid+1,r);
int k=0,i=l,j=mid+1;
while(i<=mid && j<=r)
{
if(q[i]<=q[j])tmp[k++]=q[i++];
else
{
tmp[k++]=q[j++];
res+=mid-i+1;
}
}
while(i<=mid)
{
tmp[k++]=q[i++];
}
while(j<=r)
{
tmp[k++]=q[j++];
}
for(int i=l,j=0;i<=r;i++,j++)
{
q[i]=tmp[j];
}
return res;
}
int main()
{
int n;
cin>>n;
for(int i=0;i<n;i++)scanf("%d",&q[i]);
LL res=mergesort(q,0,n-1);
cout<<res;
return 0;
}3、小朋友排队（第五届蓝桥杯 省赛 C++ B组/C组）
n 个小朋友站成一排。
现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。
每个小朋友都有一个不高兴的程度。
开始的时候，所有小朋友的不高兴程度都是 0。
如果某个小朋友第一次被要求交换，则他的不高兴程度增加 1，如果第二次要求他交换，则他的不高兴程度增加 2（即不高兴程度为 3），依次类推。当要求某个小朋友第 k次交换时，他的不高兴程度增加 k。
请问，要让所有小朋友按从低到高排队，他们的不高兴程度之和最小是多少。
如果有两个小朋友身高一样，则他们谁站在谁前面是没有关系的。
输入格式
输入的第一行包含一个整数 n，表示小朋友的个数。
第二行包含 n 个整数 H1,H2,…,Hn分别表示每个小朋友的身高。
输出格式
输出一行，包含一个整数，表示小朋友的不高兴程度和的最小值。
数据范围
1≤n≤100000
0≤Hi≤10000000
输入样例：
3
3 2 1
输出样例：
9
样例解释
首先交换身高为3和2的小朋友，再交换身高为3和1的小朋友，再交换身高为2和1的小朋友，每个小朋友的不高兴程度都是3，总和为9。
思路：
我们可以发现，每个小朋友的不高兴值都是一个等差数列（1+2+3+.....）
所以只要我们求出每个小朋友的交换次数就能求出来他们的不高兴值（等差数列求和）
在归并排序的基础上，想办法统计每个小朋友的交换次数：
那就是每次排序的时候统计每个小朋友需要向前走多少"步"，这里为了保证准确的记录小朋友的交换次数，我们选择给每个小朋友编号，用一个pair数组存储小朋友的信息，first存储身高，second存储编号，这样每次都能把步数准确的增加到编号对应的哈希表的位置上
这里选择用一个数组模拟哈希表（速度快），然后对哈希表每个位置进行等差数列（公差为1）求和，最后全加到res上
代码：
#include <iostream>
using namespace std;
#define x first
#define y second
typedef long long LL;
typedef pair<int,int> PII;
const int N = 100010;
PII w[N];
PII temp[N];
LL h[N];
int n;
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 i = l, j = mid + 1,k = 0;
while(i <= mid && j <= r) {
if(w[i] <= w[j]) {
h[w[i].y] += j - mid - 1; // 相对于i来说，j 前面的数都比它小
temp[k ++] = w[i ++];
}
else {
h[w[j].y] += mid - i + 1; // 相对于j来说，i 后面的数都比它大
temp[k ++] = w[j ++];
}
}
while(i <= mid) {
temp[k ++] = w[i ++];
}
while(j <= r){
temp[k ++] = w[j ++];
}
for(i = l,j = 0;i <= r;i ++,j ++) w[i] = temp[j];
}
int main()
{
cin >> n;
for(int i = 0;i < n;i ++) scanf("%d",&w[i].x), w[i].y = i;
merge_sort(0,n - 1);
LL res = 0;
for(int i = 0;i < n;i ++) {
res += (1 + h[i]) * h[i] / 2;
}
cout << res << endl;
return 0;
}
4、超快速排序（《算法竞赛进阶指南》）
在这个问题中，您必须分析特定的排序算法----超快速排序。
该算法通过交换两个相邻的序列元素来处理 n 个不同整数的序列，直到序列按升序排序。
对于输入序列 9 1 0 5 4，超快速排序生成输出 0 1 4 5 9。
您的任务是确定超快速排序需要执行多少交换操作才能对给定的输入序列进行排序。
输入格式
输入包括一些测试用例。
每个测试用例的第一行输入整数 n，代表该用例中输入序列的长度。
接下来 n 行每行输入一个整数 ai,代表用例中输入序列的具体数据，第 i行的数据代表序列中第 i 个数。
当输入用例中包含的输入序列长度为 0 时，输入终止，该序列无需处理。
输出格式
对于每个需要处理的输入序列，输出一个整数 op，代表对给定输入序列进行排序所需的最小交换操作数，每个整数占一行。
数据范围
0≤n<5000000
一个测试点中，所有 n 的和不超过 500000。
0≤ai≤999999999
输入样例：
5
9
1
0
5
4
3
1
2
3
0
输出样例：
6
0思路：
和逆序对模板几乎一模一样，只需一个变量来维护结果即可
代码：
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=5e5+5;
LL n,m;
LL q[N],tmp[N];
LL merge(int l,int r)
{
if(r<=l)return 0;
LL res=0;
LL mid=(l+r)>>1;
res+=merge(l,mid);res+=merge(mid+1,r);
int k=0,i=l,j=mid+1;
while(i<=mid && j<=r)
{
if(q[i]<=q[j])tmp[k++]=q[i++];
else
{
tmp[k++]=q[j++];
res+=(LL)mid-i+1;
}
}
while(i<=mid)
{
tmp[k++]=q[i++];
}
while(j<=r)
{
tmp[k++]=q[j++];
}
for(int i=l,j=0;i<=r;j++,i++)
{
q[i]=tmp[j];
}
return res;
}
int main()
{
while(cin>>n)
{
if(n==0)break;
for(int i=0;i<n;i++)cin>>q[i];
LL res=0;
res+=merge(0,n-1);
cout<<res<<endl;
}
return 0;
}5、火柴排队（NOIP2013提高组）
涵涵有两盒火柴，每盒装有 n根火柴，每根火柴都有一个高度。
现在将每盒中的火柴各自排成一列，同一列火柴的高度互不相同，两列火柴之间的距离定义为：
其中 ai 表示第一列火柴中第 i个火柴的高度，bi表示第二列火柴中第 i 个火柴的高度。
每列火柴中相邻两根火柴的位置都可以交换，请你通过交换使得两列火柴之间的距离最小。
请问得到这个最小的距离，最少需要交换多少次？
如果这个数字太大，请输出这个最小交换次数对 99,999,997取模的结果。
输入格式
共三行，第一行包含一个整数 n，表示每盒中火柴的数目。
第二行有 n 个整数，每两个整数之间用一个空格隔开，表示第一列火柴的高度。
第三行有 n 个整数，每两个整数之间用一个空格隔开，表示第二列火柴的高度。
输出格式
输出共一行，包含一个整数，表示最少交换次数对 99,999,997 取模的结果。
数据范围
1≤n≤1e5
0≤火柴高度≤1e9
输入样例：
4
2 3 1 4
3 2 1 4
输出样例：
1
思路：
本体的解决方案就是把两列火柴按顺序排列，两列中每个位置的火柴在其队列中的相对顺序要一样（简单来说就是最大的对应最大的，小的对应小的，要一一对应）
1、由于每个数据范围太大，但数据数量又没那么多，所以我们先对数据进行离散化处理，按相对大小来排序，使得他们的编号都在1~n之间
2、由于我们只要相对顺序，那么我们只需实现一个双映射即可，这样就能实现只排序一个数组，然后记录逆序对数量即可
细节问题看代码中对应的注释
代码：
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
const int MOD=99999997;
typedef long long LL;
int n;
int a[N],b[N],c[N],tmp[N];
int p[N]; //离散化后的结果存在p数组内
//要一一对应，就能让距离最小
//离散化
void work(int a[])
{
for(int i=1;i<=n;i++)p[i]=i;
sort(p+1,p+n+1,[&](int x,int y)
{
{
return a[x]<a[y];
}
});
for(int i=1;i<=n;i++)a[p[i]]=i;//a中第i小的数的值为i，索引为p【i】，在a中赋值为i表示第i小的在a中第几个
}
int merge(int l,int r)
{
if(r<=l)return 0;
int mid=(l+r)>>1;
int res=(merge(l,mid)+merge(mid+1,r))%MOD;
int k=0,i=l,j=mid+1;
while(i<=mid && j<=r)
{
if(b[j]>=b[i])tmp[k++]=b[i++];
else
{
res=(res+mid-i+1) % MOD;
tmp[k++]=b[j++];
}
}
while(i<=mid)
{
tmp[k++]=b[i++];
}
while(j<=r)
{
tmp[k++]=b[j++];
}
for(int i=l,j=0;j<k;i++,j++)
{
b[i]=tmp[j];
}
return res;
}
int main()
{
cin>>n;
for(int i=1;i<=n;i++)cin>>a[i];
for(int i=1;i<=n;i++)cin>>b[i];
//让位置一一对应即可
work(a);work(b);
//work离散化之后，a和b都是挨着排序的，并且序号都是1-n
//并且是按照原来数组中从大到小的索引排列的
//比如最低的火柴的索引是3，那么3就在最前面
for(int i=1;i<=n;i++)c[a[i]]=i; //把第三个位置的映射统一变成1
for(int i=1;i<=n;i++)b[i]=c[b[i]];//把b按照映射重组一下
//for(int i=1;i<=n;i++)cout<<b[i];
int res=merge(1,n);
cout<<res;
return 0;
}
扫一扫
984
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
