算法竞赛进阶指南基本算法 0x05 排序

本文链接：https://blog.csdn.net/m0_51448653/article/details/126372737

离散化

可以把a数组排序并去掉重复的值，得到有序数组b，在b数组的下标i与数值b[i]之间建立映射关系；若要查询整数a[j]( $\leq n$ )被哪个1～m之间的整数代替，只需在b数组中二分查找a[j]的位置即可

void discrete() { // 离散化
    sort(a + 1, a + n + 1);
    for (int i = 1; i <= n; ++ i) 
    if (i == 1 || a[i] != a[i - 1])
        b[ ++ m] = a[i];
}

int query(int x) {  // 查询x映射为哪个1～m之间的整数
    return lower_bound(b + 1, b + m + 1) - b;
}

中位数

AcWing 104. 货仓选址

题意：

在一条数轴上有 N 家商店，它们的坐标分别为 A1∼AN。
现在需要在数轴上建立一家货仓，每天清晨，从货仓到每家商店都要运送一车商品。
为了提高效率，求把货仓建在何处，可以使得货仓到每家商店的距离之和最小。

思路：

把a数组排序，设货仓在x坐标，左边有p家，右边有q家；若p>q，每把货仓往左移一个单位，总距离减小p-q；若p<q，每把货仓往右移一个单位，总距离减小q-p；因此，当p=q时最优解
因此，货仓建在中位数处；注意当n为偶数时，货仓建在 $a [n /2]$ ~ $a [n /2 + 1]$ （下标从1）之间的任何位置都是最优解；由于n为奇数时，货仓建在 $a [n /2 + 1]$ ；因此，不论n奇偶，我们统一建立在 $a [n /2 + 1]$

#include <iostream>
#include <algorithm>
#define endl '\n'
#define _(a) cout << #a << ": " << (a) << "    "
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 1e5 + 10;

int n;
int a[N];

int main() {
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin >> n;
    for (int i = 1; i <= n; ++ i) cin >> a[i];
    sort(a + 1, a + n + 1);
    ll ans = 0;
    int now = a[n / 2 + 1];
    for (int i = 1; i <= n; ++ i) ans += (ll)(abs(now - a[i]));
    cout << ans;
}

(-)AcWing 105. 七夕祭

AcWing 106. 动态中位数

题意：

依次读入一个整数序列，每当已经读入的整数个数为奇数时，输出已读入的整数构成的序列的中位数。
每个数据集的第一行首先输入一个代表数据集的编号的整数。
然后输入一个整数 M，代表数据集中包含数据的个数，M 一定为奇数，数据之间用空格隔开。
对于每个数据集，第一行输出两个整数，分别代表数据集的编号以及输出中位数的个数（应为数据个数加一的二分之一），数据之间用空格隔开。
数据集的剩余行由数据集的数据构成，每行包含 10 个数据，最后一行数据量可能少于 10 个，数据之间用空格隔开。

思路：

使用“对顶堆”算法
建立两个二叉堆：一个小根堆、一个大根堆；在依次读入这个整数序列的过程中，设当前序列长度为M，我们始终保持：
1、序列中从小到大排名为1～M/2+1的整数存储在大根堆中
2、序列中从小到大排名为M/2～M的整数存出在小根堆中
任何时候，如果某一个堆中元素个数过多，打破了这个性质，就取出该堆的堆顶插入另一个堆
这样一来，序列的中位数就是大根堆的堆顶
每次新读入一个X，先插入大根堆，然后动态调整大根堆与小根堆的元素

#include <iostream>
#include <queue>
#define endl '\n'
#define _(a) cout << #a << ": " << (a) << "    "
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;

int main() {
    int _; cin >> _;
    while (_ -- ) {
        int m, n;
        scanf("%d%d", &m, &n);
        printf("%d %d\n", m, (n + 1) / 2);
        priority_queue<int> max_ele;
        priority_queue<int, vector<int>, greater<int>> min_ele;
        int cnt = 0;
        for (int i = 1, x; i <= n && scanf("%d", &x); ++ i) {
            max_ele.push(x);
            if (min_ele.size() && min_ele.top() < max_ele.top()) {
                int a = max_ele.top(); max_ele.pop();
                int b = min_ele.top(); min_ele.pop();
                max_ele.push(b);
                min_ele.push(a);
            }
            if (max_ele.size() > min_ele.size() + 1) {
                min_ele.push(max_ele.top());
                max_ele.pop();
            }
            if (i & 1) {
                printf("%d ", max_ele.top());
                if ( ++ cnt % 10 == 0) puts("");
            }
        }
        if (cnt % 10) puts("");
    }
}

第k大数

给定n个整数，利用类似于快排思想，只需要O(n)的时间即可求出第k大数
从大到小进行快排算法的思想：在每一层递归中，随机选取一个数作为基准，比它大的数交换到“左半段”，其余的数和基准值自身一起作为“右半段”；然后继续递归对左右两边分别进行排序，在平均情况下快排的复杂度为O(nlogn)
实际上在每次选取基准值后，我们可以统计出大于基准值的数的数列cnt，如果 $\leq cnt$ ，我们就在左半段寻找第k大数；否则，就在右半段（小于等于）寻找第 $k - c n t$ 大数；因此，寻找第k大数时，我们只需要进入左右两半二分之一继续递归，在平均情况下，复杂度为 $n + n /2 + n /4 + ... + 1 = O (n)$

逆序对

使用归并排序可以在O(nlogn)时间里求出一个长度为n的序列中逆序对的个数；归并排序每次把序列二分，递归对左右两半排序，然后合并两个有序序列
递归对左右两半排序时，可以把左右两半各自内部的逆序对数作为子问题计算，因此我们只需要在合并时考虑“左边一半里较大的数”与“右边一半里较小的数”构成逆序对的情形，求出这种情形的个数
合并两个有序序列a[l ~ mid]与a[mid+1 ~ r]可以采用两个指针i与j分别对二者进行扫描的方式，不断比较两个指针所指向数值a[i]与a[j]的大小，将小的那个加入到排序的结果数组中；若小的那个是a[j]，则a[i ~ mid]都比a[j]要大，它们都会与a[j]构成逆序对，可以顺便统计到答案中

AcWing 107. 超快速排序

题意：

该算法通过交换两个相邻的序列元素来处理 n 个不同整数的序列，直到序列按升序排序。
您的任务是确定超快速排序需要执行多少交换操作才能对给定的输入序列进行排序。
$0 \leq n < 500000$

思路：

只通过比较和交换相邻两个数值的排序方法，实际上就是冒泡排序
在排序过程中每找到一对大小颠倒的相邻数值，把它们交换，整个序列的逆序对个数减少1，最终排好序后逆序对个数显然为0
因此对a进行冒泡排序需要的最少交换次数就是序列a中逆序对的个数
因此，我们使用归并排序求出a中逆序对的对数

#include <iostream>
#define endl '\n'
#define _(a) cout << #a << ": " << (a) << "    "
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 5e5 + 10;

int n;
int a[N], tmp[N];

ll merge(int q[], int l, int r) {
    if (l >= r) return 0;
    
    int mid = l + r >> 1;
    
    ll ans = merge(q, l, mid) + merge(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 {
            ans += mid - i + 1;
            tmp[k ++ ] = q[j ++ ];
        }
    }
    while (i <= mid) tmp[k ++ ] = q[i ++ ];
    while (j <= r) tmp[k ++ ] = q[j ++ ];
    
    for (i = l, j = 0; j < k; ++ i, ++ j) q[i] = tmp[j];
    
    return ans;
}

int main() {
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    while (cin >> n && n) {
        for (int i = 0; i < n; ++ i) cin >> a[i];
        cout << merge(a, 0, n - 1) << endl;
    }
}