算法竞赛进阶指南（基本算法）：排序

gnayqh

已于 2023-09-15 15:56:31 修改

阅读量503

点赞数

分类专栏： c++ 文章标签：数据结构算法 c++ 排序算法

于 2023-01-09 22:35:31 首次发布

本文链接：https://blog.csdn.net/sdfzhqy/article/details/128620781

版权

c++ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

背景知识：

1.常用排序

常用的排序算法通常会使用以下几种：

选择排序，插入排序，冒泡排序

堆排序，归并排序，快速排序

基数排序，计数排序，桶排序

而前两类的时间复杂度分别为：O（n^2), O(n* log n),第三类的时间复杂度不仅与n有关，而且还与数值的取值范围有关。

2.离散化

笼统地说，离散化是把一些分散的且无穷大集合中的某些元素映射为有限集合的方法，以便于统计

这样就能有效减小数组的空间范围，并减少被浪费的空间

离散化，把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。

通俗的说，离散化是在不改变数据相对大小的条件下，对数据进行相应的缩小。------百度百科

例题：

- AcWing 103. 电影

题目描述

莫斯科正在举办一个大型国际会议，有 n 个来自不同国家的科学家参会。

每个科学家都只懂得一种语言。

为了方便起见，我们把世界上的所有语言用 1到 109 之间的整数编号。

在会议结束后，所有的科学家决定一起去看场电影放松一下。

他们去的电影院里一共有 m 部电影正在上映，每部电影的语音和字幕都采用不同的语言。

对于观影的科学家来说，如果能听懂电影的语音，他就会很开心；如果能看懂字幕，他就会比较开心；如果全都不懂，他就会不开心。

现在科学家们决定大家看同一场电影。

请你帮忙选择一部电影，可以让观影很开心的人最多。

如果有多部电影满足条件，则在这些电影中挑选观影比较开心的人最多的那一部。

输入格式

第一行输入一个整数 n，代表科学家的数量。

第二行输入 n 个整数 a1,a2…an，其中 ai 表示第 i 个科学家懂得的语言的编号。

第三行输入一个整数 mm，代表电影的数量。

第四行输入 m 个整数 b1,b2…bm，其中 bi表示第 i 部电影的语音采用的语言的编号。

第五行输入 m 个整数 c1,c2…cm,其中 ci 表示第 i 部电影的字幕采用的语言的编号。

请注意对于同一部电影来说，bi≠ci。

同一行内数字用空格隔开。

输出格式

输出一个整数，代表最终选择的电影的编号。电影编号 1∼m。

如果答案不唯一，输出任意一个均可。

数据范围

1≤n,m≤200000,

1≤ai,bi,ci≤109,

输入样例：

输出样例：

思路

这里运用了离散化思想，由于科学家所懂语言的数据量较大且分散，我们把所有电影和人包括了的语言放入一个数组，并排序运用离散化

这里我们可以用map或是unordered——map来存

具体操作

- 结构体：用结构体存电影的语言和字幕

- 分别比较出哪个电影能让最多科学家开心（即符合语言最多的情况）

- 若2操作出现有电影相同，则比较电影的字幕

代码实现：


#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
int a[N];
struct ST{
    int x;//电影的语言
    int y;//电影的字幕
}st[N];
int main(){
    int n;
    cin>>n;
    map<int,int> q;
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        q[a[i]]++;//计算出各个语言出现的数量
    }
    int m;
    cin>>m;
    int maxn=-1;//用来指向哪个电影的语言符合最多科学家
    int k;
    for(int i=1;i<=m;i++){
        scanf("%d",&st[i].x);
    }
    for(int i=1;i<=m;i++){
        scanf("%d",&st[i].y);
    }
    for(int i=1;i<=m;i++){
         if(q[st[i].x]>maxn){
              k=i;
               maxn=q[st[i].x];//更新最优值
          }
        else if(q[st[i].x]==maxn){//如果出现最优值符合多个电影的情况
                if(q[st[i].y]>q[st[k].y]){//则比较他们的字幕
                   k=i;
                   maxn=q[st[i].x];
                }
            }
    }
    cout<<k<<endl;   
    return 0;
}

2.AcWing 104. 货仓选址

题目描述

在一条数轴上有 N 家商店，它们的坐标分别为 A1∼AN。

现在需要在数轴上建立一家货仓，每天清晨，从货仓到每家商店都要运送一车商品。

为了提高效率，求把货仓建在何处，可以使得货仓到每家商店的距离之和最小。

输入格式

第一行输入整数 N。

第二行 N 个整数 A1∼AN。

输出格式

输出一个整数，表示距离之和的最小值。

数据范围

1≤N≤100000

0≤Ai≤40000

输入样例：


4
6 2 9 1

输出样例：

思路

不难发现。

若n为偶数，则选择的货仓应该存在与a[n/2]~a[n/2+1]之间为最优情况。

若n为奇数，则选择的货仓应存在与a[n/2]为最优情况

代码实现


#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
int a[N];
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++)cin>>a[i];
    sort(a,a+n);
    int res=0;
    for(int i=0;i<n;i++)res+=abs(a[i]-a[n/2]);
    cout<<res;
    return 0;
}

3.AcWing 106. 动态中位数

题目描述

依次读入一个整数序列，每当已经读入的整数个数为奇数时，输出已读入的整数构成的序列的中位数。

输入格式

第一行输入一个整数 P，代表后面数据集的个数，接下来若干行输入各个数据集。

每个数据集的第一行首先输入一个代表数据集的编号的整数。

然后输入一个整数 M，代表数据集中包含数据的个数，M 一定为奇数，数据之间用空格隔开。

数据集的剩余行由数据集的数据构成，每行包含 10 个数据，最后一行数据量可能少于 10 个，数据之间用空格隔开。

输出格式

对于每个数据集，第一行输出两个整数，分别代表数据集的编号以及输出中位数的个数（应为数据个数加一的二分之一），数据之间用空格隔开。

数据集的剩余行由输出的中位数构成，每行包含 10 个数据，最后一行数据量可能少于 10个，数据之间用空格隔开。

输出中不应该存在空行。

数据范围

1≤P≤1000

1≤M≤99999

所有 M 相加之和不超过 5×105

输入样例：


3 
1 9 
1 2 3 4 5 6 7 8 9 
2 9 
9 8 7 6 5 4 3 2 1 
3 23 
23 41 13 22 -3 24 -31 -11 -8 -7 
3 5 103 211 -311 -45 -67 -73 -81 -99 
-33 24 56

输出样例：


1 5
1 2 3 4 5
2 5
9 8 7 6 5
3 12
23 23 22 22 13 3 5 5 3 -3 
-7 -3

思路：

乍一看题目似乎很简单，

这里要分别开两个堆，一个是大根堆，一个是小根堆，符合条件时输出小根堆堆顶

小于中位数的都放在大根堆，大于中位数的都放在小根堆，如果说，一个堆的个数大于了当前序列的1/2，那么就将多余的数移过去，直到两个堆数量相等 ------某位大佬

即始终保持：

序列中从小到大排名为1~M/2的整数存储在大根堆中

序列中总小到大排名为M/2~M的整数存储在小根堆中

具体操作

若小根堆r为空或输入的数大于r的堆顶元素，则将数存入r中，反之将数存入大根堆l中

2.

若是小根堆r中的元素个数大于大根堆l中的元素个数+1，则取出r的堆顶元素放入l中

若是大根堆l中的元素个数大于小根堆r中的元素个数，则取出l的堆顶元素放入r中

保持这两种性质，这样一来序列的中位数就是小根堆的堆顶

3.

若数的下标是奇数，则输出小根堆r的堆顶

代码实现


#include <bits/stdc++.h>
using namespace std;
int N,xh,n,x;
int main(){
    cin>>N;
    while(N--){
        scanf("%d%d",&xh,&n);
        cout<<xh<<" "<<(n+1)/2<<endl;
        priority_queue<int> l;//大根堆
        priority_queue<int,vector<int>,greater<int> > r;//小根堆
        for(int i=1;i<=n;i++){
            scanf("%d",&x);
            if(r.empty() || x>=r.top()){
                r.push(x);
            }
            else l.push(x);
            if(r.size()&&r.size()>((i+1)/2)){//交换元素以控制两个堆的平衡
                l.push(r.top());
                r.pop();
            } 
            if(l.size()&&l.size()>(i/2)){
                r.push(l.top());
                l.pop();
            } 
            if(i%2)cout<<r.top()<<" ";//处理输出
            if(i%20==0)cout<<endl;//处理输出格式
        }
        cout<<endl;
    }
    return 0;
}

4.AcWing 107. 超快速排序

题目描述

在这个问题中，您必须分析特定的排序算法----超快速排序。

该算法通过交换两个相邻的序列元素来处理 nn 个不同整数的序列，直到序列按升序排序。

对于输入序列 9 1 0 5 4，超快速排序生成输出 0 1 4 5 9。

您的任务是确定超快速排序需要执行多少交换操作才能对给定的输入序列进行排序。

输入格式

输入包括一些测试用例。

每个测试用例的第一行输入整数 n，代表该用例中输入序列的长度。

接下来 n 行每行输入一个整数 ai,代表用例中输入序列的具体数据，第 i 行的数据代表序列中第 i个数。

当输入用例中包含的输入序列长度为 0时，输入终止，该序列无需处理。

输出格式

对于每个需要处理的输入序列，输出一个整数 op，代表对给定输入序列进行排序所需的最小交换操作数，每个整数占一行。

数据范围

0≤n<500000

一个测试点中，所有 n 的和不超过 500000

0≤ai≤999999999

输入样例：

输出样例：

6
0

思路

我们发现该题就是求取逆序对，即前后相互比较，不难想到，类似于归并排序，每次把序列二分在递归左右两边进行排序。

而出现逆序对的情况就是对于序列a,若i<j,且a[i]>a[j]，则构成逆序对

代码实现


#include<bits/stdc++.h>//求逆序对，利用归并排序
using namespace std;
const int N=5e6+10;
typedef long long LL;
int a[N],b[N];
int n;
LL res;
void msort(int l,int r){
    int i,k,j;
    if(l==r)return;//若左右两端点重合则跳出
    int mid=(l+r)/2;//取分界点
    msort(l,mid);//递归处理两边
    msort(mid+1,r);
    i=k=l,j=mid+1;//i为左半边起始点，j为右半边起始点
    while(i<=mid && j<=r){//两指针都还为到达终点
        if(a[i]<=a[j])b[k++]=a[i++];//不是逆序对，则往b中先放入更小的值
        else{//是逆序对
            b[k++]=a[j++];
            res+=mid-i+1;//因为前面的都是顺序的，则该数与前面的数都形成逆序对
        }
    }
    while(i<=mid)b[k++]=a[i++];//左边还有点没走完
    while(j<=r)b[k++]=a[j++];//右边还有点没走完
    for(int i=l;i<=r;i++)a[i]=b[i];
}
int main(){
    while(cin>>n){
        if(n==0)break;//若输入0则程序结束
        res=0;//每一次询问初始化res为0
        for(int i=0;i<n;i++){
            scanf("%d",&a[i]);
        }
        msort(0,n-1);//引入左右端点
        cout<<res<<endl;
    }
    return 0;
}