洛谷 P1022 瑞士轮

前言

最近准备弄个解密，欢迎大家参加！

正文

题意

$2N$ 个人进行比赛。
比赛的规则如下：

1. 比赛将会进行 $R$ 轮。
2. 每轮按分数从大到小排序，相同的按编号从小到大排序。
3. 每轮第 $1$ 名和第 $2$ 名比，第 $3$ 名和第 $4$ 名比……第 $2N - 1$ 名和第 $2N$ 名比。
4. 每人都有个实力值，比赛中实力值大的获得 $1$ 分。

问最终谁是第 $Q$ 名。

思路

$60pts$

直接暴力sort。（逃
时间复杂度： $O(R(N\log ( N ) + N))$

$100pts$

细想一下，刚才我们的时间浪费在哪？
当然是！sort！
sort的时间复杂度高达 $O(N\log ( N ))$，我们可以在这个上做文章。
分赢家和输家看：

• 赢家们排序前是降序，现在都加了 $1$ ，还是降序；
• 输家们排序前是降序，现在不变，还是降序；

赢家输家不变，就赢家可能超过了输家，你告诉我要sort？？
我要请出一个重量级的东西——归并排序！
赢家输家都是有序的，那么就只需要用归并就行了。
啥？你没学过归并排序？先说归并吧！
归并，把两个有序数组合并成一个有序数组，时间复杂度为 $O(n)$。
每次把两个开头比较：

• 第一个开头大（小），就把第一个压进答案数组；
• 第二个开头大（小），就把第二个压进答案数组；
• 无论是哪个大（小），都得把它删掉。

会了吧？
时间复杂度： $O(RN)$ ，可以通过。（话说 $500ms$ 真是丧（gan）心（de）病（piao）狂（liang））

代码

#include <bits/stdc++.h>
using namespace std;

template<typename T>
void merge(T * _A, T * _B, T * _C, int _A_Len, int _B_Len) { // 归并 
	T * _A_Begin = _A;
	T * _B_Begin = _B;
	T * _Mark = _C;
	while (_A_Begin < _A + _A_Len && _B_Begin < _B + _B_Len) {
		if (*_A_Begin > *_B_Begin) {
			*(_Mark++) = *(_A_Begin++); // 置A 
		} else {
			*(_Mark++) = *(_B_Begin++); // 置B 
		}
	}
	while (_A_Begin < _A + _A_Len) {
		*(_Mark++) = *(_A_Begin++);
	}
	while (_B_Begin < _B + _B_Len) {
		*(_Mark++) = *(_B_Begin++);
	}
}

pair<int, int> a[200005];
pair<int, int> win[200005]; // 赢家 
pair<int, int> lose[200005]; // 输家 

int w[200005];

int main() {
	int N, R, Q;
	scanf("%d %d %d", &N, &R, &Q);
	N *= 2;
	for (int i = 0; i < N; i++) {
		a[i].second = -i; // 取负（有及时再取负吗？） 
		scanf("%d", &a[i].first);
	}
	for (int i = 0; i < N; i++) {
		scanf("%d", &w[i]);
	}
	sort(a, a + N, greater<pair<int, int> >());
	for (int i = 0; i < R; i++) {
		int wins = 0, loses = 0;
		for (int j = 0; j < N; j += 2) {
			if (w[-a[j].second] > w[-a[j + 1].second]) { // 有 
				a[j].first++; // 分数加1 
				win[wins++] = a[j];
				lose[loses++] = a[j + 1];
			} else {
				a[j + 1].first++; // 分数加1 
				lose[loses++] = a[j];
				win[wins++] = a[j + 1];
			}
		}
		merge(win, lose, a, wins, loses); // 合并 
	}
	printf("%d", -a[Q - 1].second + 1); // 输出及时取负 
	return 0;
}