洛古P1309 瑞士轮（//归并排序和暴力搜索了解一下）

题目背景

在双人对决的竞技性比赛，如乒乓球、羽毛球、国际象棋中，最常见的赛制是淘汰赛和循环赛。前者的特点是比赛场数少，每场都紧张刺激，但偶然性较高。后者的特点是较为公平，偶然性较低，但比赛过程往往十分冗长。

本题中介绍的瑞士轮赛制，因最早使用于 $1895$ 年在瑞士举办的国际象棋比赛而得名。它可以看作是淘汰赛与循环赛的折中，既保证了比赛的稳定性，又能使赛程不至于过长。

题目描述

$2\times N$ 名编号为 $1-2N$ 的选手共进行R 轮比赛。每轮比赛开始前，以及所有比赛结束后，都会按照总分从高到低对选手进行一次排名。选手的总分为第一轮开始前的初始分数加上已参加过的所有比赛的得分和。总分相同的，约定编号较小的选手排名靠前。

每轮比赛的对阵安排与该轮比赛开始前的排名有关：第 $1$ 名和第 $2$ 名、第 $3$ 名和第 $4$ 名、……、第 $2K-1$ 名和第 $2K$ 名、…… 、第 $2N-1$ 名和第 $2N$ 名，各进行一场比赛。每场比赛胜者得 $1$ 分，负者得 $0$ 分。也就是说除了首轮以外，其它轮比赛的安排均不能事先确定，而是要取决于选手在之前比赛中的表现。

现给定每个选手的初始分数及其实力值，试计算在R 轮比赛过后，排名第 $Q$ 的选手编号是多少。我们假设选手的实力值两两不同，且每场比赛中实力值较高的总能获胜。

输入输出格式

输入格式：

第一行是三个正整数 $N,R,Q$ ,每两个数之间用一个空格隔开，表示有 $2\times N$ 名选手、 $R$ 轮比赛，以及我们关心的名次 $Q$ 。

第二行是 $2\times N$ 个非负整数 s_1, s_2, …, s_{2N}s1​,s2​,…,s2N​ ，每两个数之间用一个空格隔开，其中 s_isi​ 表示编号为 $i$ 的选手的初始分数。 第三行是 $2\times N$ 个正整数 w_1 , w_2 , …, w_{2N}w1​,w2​,…,w2N​ ，每两个数之间用一个空格隔开，其中 w_iwi​ 表示编号为 $i$的选手的实力值。

输出格式：

一个整数，即 $R$ 轮比赛结束后，排名第 $Q$ 的选手的编号。

输入输出样例

输入样例#1：  复制

2 4 2 
7 6 6 7 
10 5 20 15 

输出样例#1：  复制

1

说明

【样例解释】

【数据范围】

对于 $30\%$ 的数据， $1\le N\le 100$ ；

对于 $50\%$ 的数据， $1\le N\le 10,000$ ；

对于 $100\%$ 的数据， 1 ≤ N ≤ 100,000,1 ≤ R ≤ 50,1 ≤ Q ≤ 2N,0 ≤ s_1, s_2, …, s_{2N}≤10^8,1 ≤w_1, w_2 , …, w_{2N}≤ 10^81≤N≤100,000,1≤R≤50,1≤Q≤2N,0≤s1​,s2​,…,s2N​≤108,1≤w1​,w2​,…,w2N​≤108。

noip2011普及组第3题。

此题我的想法就是归并和爆搜；

可是菜鸟的我一直wa

最后找出来原来是每次排完有的数组里面的数没有完全取出来，所以就要想办法找出来所有的数组；；

#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
struct re
{
    int pos;
    int sc;
    int str;
}
a[200000],win[200000],los[200000];
int cmp(re a,re b)
{
    if(a.sc!=b.sc)return a.sc>b.sc;
    else return a.pos<b.pos;
}
int main()
{
    ios::sync_with_stdio(false);
    int n,r,q;
    cin>>n>>r>>q;
    for(int i=1;i<=2*n;i++)
    {
        a[i].pos=i;
        cin>>a[i].sc;
    }
    for(int i=1;i<=2*n;i++)
    {
        cin>>a[i].str;
    }
    sort(a+1,a+2*n+1,cmp);
    while(r--)
    {
        ll k=1,w=1;
        for(int i=1;i<=2*n;i+=2)
        {
            if(a[i].str>a[i+1].str)
            {
                a[i].sc+=1;
                win[k].sc=a[i].sc;
                win[k].str=a[i].str;
                win[k].pos=a[i].pos;
                los[w].sc=a[i+1].sc;
                los[w].str=a[i+1].str;
                los[w].pos=a[i+1].pos;
                k++;
                w++;
            }
            else
            {
                a[i+1].sc+=1;
                win[k].sc=a[i+1].sc;
                win[k].str=a[i+1].str;
                win[k].pos=a[i+1].pos;
                los[w].sc=a[i].sc;
                los[w].str=a[i].str;
                los[w].pos=a[i].pos;
                k++;
                w++;
            }
        }
        win[k].str=-1;
        win[k].sc=-1;
        win[k].pos=-1;
        los[k].str=-1;
        los[k].sc=-1;
        los[k].pos=-1;
        ll g=1;
        ll i=1,j=1;
        while(i<k||j<w)
        {
            if(win[i].sc<los[j].sc)//分割数组，赢得一组输的一组，这两个数组都有顺序，然后归并
            {
                a[g].sc=los[j].sc;
                a[g].pos=los[j].pos;
                a[g].str=los[j].str;
                g++;
                j++;
            }
            else if(win[i].sc==los[j].sc)
            {
                if(win[i].pos<los[j].pos)
                {
                    a[g].sc=win[i].sc;
                    a[g].str=win[i].str;
                    a[g].pos=win[i].pos;
                    g++;
                    i++;
                }
                else
                {
                    a[g].sc=los[j].sc;
                    a[g].str=los[j].str;
                    a[g].pos=los[j].pos;
                    g++;
                    j++;
                }
            }
            else
            {
                a[g].sc=win[i].sc;
                a[g].str=win[i].str;
                a[g].pos=win[i].pos;
                g++;
                i++;
            }
        }
    }
    sort(a+1,a+2*n+1,cmp);
    cout<<a[q].pos<<endl;
    return 0;
}