瑞士轮

4363:瑞士轮

总时间限制: 

2000ms 

单个测试点时间限制: 

1000ms 

内存限制: 

65535kB

描述

【背景】 
在双人对决的竞技性比赛，如乒乓球、羽毛球、国际象棋中，最常见的赛制是淘汰赛和循环赛。前者的特点是比赛场数少，每场都紧张刺激，但偶然性较高。后者的特点是较为公
平，偶然性较低，但比赛过程往往十分冗长。 
本题中介绍的瑞士轮赛制，因最早使用于 1895 年在瑞士举办的国际象棋比赛而得名。它可以看作是淘汰赛与循环赛的折衷，既保证了比赛的稳定性，又能使赛程不至于过长。 

【问题描述】 
2*N名编号为 1~2N的选手共进行 R轮比赛。每轮比赛开始前，以及所有比赛结束后，都会按照总分从高到低对选手进行一次排名。 选手的总分为第一轮开始前的初始分数加上已参加过的所有比赛的得分和。总分相同的，约定编号较小的选手排名靠前。 每轮比赛的对阵安排与该轮比赛开始前的排名有关：第 1 名和第 2 名、第 3 名和第 4 名、……、第 2K – 1 名和第 2K名、……  、第 2N – 1 名和第2N名，各进行一场比赛。每场比赛胜者得 1 分，负者得 0 分。也就是说除了首轮以外，其它轮比赛的安排均不能事先确定，而是要取决于选手在之前比赛中的表现。 
现给定每个选手的初始分数及其实力值，试计算在 R 轮比赛过后，排名第 Q 的选手编号是多少。我们假设选手的实力值两两不同，且每场比赛中实力值较高的总能获胜。

输入

输入的第一行是三个正整数 N、R、Q，每两个数之间用一个空格隔开，表示有 2*N 名选手、R 轮比赛，以及我们关心的名次 Q。 
第二行是 2*N个非负整数 s₁, s₂, …, s_2N，每两个数之间用一个空格隔开，其中 s_i 表示编号为 i 的选手的初始分数。 
第三行是 2*N个正整数 w₁, w₂, …, w_2N，每两个数之间用一个空格隔开，其中 w_i 表示编号为 i 的选手的实力值。

输出

输出只有一行，包含一个整数，即 R 轮比赛结束后，排名第 Q 的选手的编号。

样例输入

2 4 2 7 6 6 7 10 5 20 15 

样例输出

1

提示

对于 30%的数据，1 ≤ N ≤ 100； 
对于 50%的数据，1 ≤ N ≤ 10,000； 
对于 100%的数据， 1 ≤ N ≤ 100,000， 1 ≤ R ≤ 50， 1 ≤ Q ≤ 2N， 0 ≤ s₁, s₂, …, s_2N ≤ 10⁸， 1 ≤ w₁, w₂, …, w_2N ≤ 10⁸。

代码

 snippet_file_0.txt 67行 C++

收起

全屏

展开

Raw

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
struct Data{
int X;
int F;
int S;
}P[200001];
bool operator >(Data A,Data B){
if(A.F !=B.F ){
return A.F >B.F;
}
else {
return A.X <B.X;
}
}
int CMP(Data A,Data B){
return A>B;
}
int main(){
int N;int R;int Q;
scanf("%d%d%d",&N,&R,&Q);
for(int i=1;i<=2*N;i++){
scanf("%d",&P[i].F );
P[i].X=i;
}
for(int i=1;i<=2*N;i++){
scanf("%d",&P[i].S );
}
sort(P+1,P+2*N+1,CMP);
while(R--){
Data S1[102000];Data S2[100100];
int k1=1;int k2=1;
for(int i=1;i<=2*N;i+=2){
Data A=P[i];
Data B=P[i+1];
if(A.S >B.S ){
A.F ++;
S1[k1++]=A;
S2[k2++]=B;
}
else if(A.S <B.S ){
B.F ++;
S1[k1++]=B;
S2[k2++]=A;
}
}
int len1=1;int len2=1;
int len=1;
while(k1!=len1&&k2!=len2){
P[len++]=S1[len1]>S2[len2]?S1[len1++]:S2[len2++];
}
if(k2!=len2){
for(int i=len2;i<k2;i++){
P[len++]=S2[i];
}
}
else if(k1!=len1){
for(int i=len1;i<k1;i++){
P[len++]=S1[i];
}
}
}
printf("%d\n",P[Q].X );
return 0;
}

思路

归并。因为是有序序列，两两比对。可以得到两个有序的结果序列——一个是赢家，一个是输家，在合并，时间复杂度比较低。

缺点

空间花费很大，数据在加强，便不行

问题

1.重载后不同的比较出用同一重载，导致出错；

2.数组定在main()函数内，可能（一定）溢出；换到堆里去吧；