P1309 瑞士轮

最新推荐文章于 2025-04-05 16:26:06 发布
原创 最新推荐文章于 2025-04-05 16:26:06 发布 · 391 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #排序算法

本文介绍了如何利用归并排序的合并思想解决P1309瑞士轮问题，针对超时的情况提出了解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题目链接

几个点超时了，看题解才学会归并（归并排序的思想就是合并两个同序数组的线性方式——每次比较两个有序数组指针指向的值，谁更小（大）则放到temp数组里）

#include <cstdio>
#include <algorithm>
using namespace std;
int n,r,q;
struct student
{
   
   
	long long int s;
	long long int w;
	int bianhao;
}stu[200002]={
   
   0};
student a[200010],win[200010],lose[200010];
bool compar(student a,student b)
{
   
   
	if(a.s==b.s) return a.bianhao<b.bianhao;
	return a.s>b.s;
}
void merge()
{
   <
最低0.47元/天 解锁文章

200万优质内容无限畅学
P1309 [NOIP2011 普及组] 瑞士轮————C++
Kinght_123的博客
01-24 1397
选手的总分为第一轮开始前的初始分数加上已参加过的所有比赛的得分和。在双人对决的竞技性比赛，如乒乓球、羽毛球、国际象棋中，最常见的赛制是淘汰赛和循环赛。现给定每个选手的初始分数及其实力值，试计算在R 轮比赛过后，排名第$ Q$ 的选手编号是多少。每场比赛胜者得$1 $分，负者得 $0 $分。也就是说除了首轮以外，其它轮比赛的安排均不能事先确定，而是要取决于选手在之前比赛中的表现。对于$50% $的数据，$1 ≤ N ≤ 10,000 $；轮比赛结束后，排名第$ Q$ 的选手的编号。对于$30% $的数据，。
P1309 【瑞士轮】
Mr.Steven_Green的博客
10-05 440
题目背景 在双人对决的竞技性比赛，如乒乓球、羽毛球、国际象棋中，最常见的赛制是淘汰赛和循环赛。前者的特点是比赛场数少，每场都紧张刺激，但偶然性较高。后者的特点是较为公平，偶然性较低，但比赛过程往往十分冗长。 本题中介绍的瑞士轮赛制，因最早使用于18951895年在瑞士举办的国际象棋比赛而得名。它可以看作是淘汰赛与循环赛的折中，既保证了比赛的稳定性，又能使赛程不至于过长。 题目描述 2 \times...
P1309瑞士轮
未来有个世界等着你
10-18 909
题目描述 2*N 名编号为 1~2N 的选手共进行R 轮比赛。每轮比赛开始前，以及所有比赛结束后，都会按照总分从高到低对选手进行一次排名。选手的总分为第一轮开始前的初始分数加上已参加过的所有比赛的得分和。总分相同的，约定编号较小的选手排名靠前。 每轮比赛的对阵安排与该轮比赛开始前的排名有关：第1 名和第2 名、第 3 名和第 4名、……、第2K – 1 名和第 2K名、…… 、第2N
c++代码P1309瑞士轮
08-28
c++代码P1309瑞士轮
P1309 瑞士轮——洛谷（归并排序C++）
Annabel_CM的博客
08-01 1390
题目背景 在双人对决的竞技性比赛，如乒乓球、羽毛球、国际象棋中，最常见的赛制是淘汰赛和循环赛。前者的特点是比赛场数少，每场都紧张刺激，但偶然性较高。后者的特点是较为公平，偶然性较低，但比赛过程往往十分冗长。 本题中介绍的瑞士轮赛制，因最早使用于18951895年在瑞士举办的国际象棋比赛而得名。它可以看作是淘汰赛与循环赛的折中，既保证了比赛的稳定性，又能使赛程不至于过长。 题目描述 2×N 名编号为 1∼2N 的选手共进行R 轮比赛。每轮比赛开始前，以及所有比赛结束后，都会按照总分从高到低对选手进行一次排名。
P1309 [NOIP 2011 普及组] 瑞士轮 C++
最新发布
C_m__的博客
04-05 938
w2N​，每两个数之间用一个空格隔开，其中 wi​ 表示编号为i 的选手的实力值。思路： 简单的排序问题，但如果直接用STL的sort会报超时，我们可以用归并排序用b和c分别记录a中的得分者和其他，此时的b c是有序数组，可以放入merge进行排序。对于100%的数据，1≤N≤100,000,1≤R≤50,1≤Q≤2N,0≤s1​,s2​,…,s2N​≤108,1≤w1​,w2​,…第一行是三个正整数N,R,Q,每两个数之间用一个空格隔开，表示有 2×N名选手、R 轮比赛，以及我们关心的名次 Q。
【洛谷P1309】瑞士轮
生息之地
09-02 561
P1309瑞士轮 本题同样是NOIP普及组第三题。 因为太久没有做过题目了，先从普及组开始练习吧。 题目内容 思路1 很显然想到的思路就是模拟，代码如下： #include <iostream> #include <vector> #include <utility> #include <algorithm> using namespace std;...
P1309 [NOIP2011 普及组] 瑞士轮
Achilles0705的博客
02-05 537
本文介绍了瑞士轮赛制在双人对决竞技性比赛中的应用。该赛制是淘汰赛与循环赛的折中，确保比赛稳定性同时避免过长。通过2×N名选手进行R轮比赛，每轮结束后按总分排序，总分相同则按编号排序。比赛规则包括每轮的对阵和得分规则。通过结构体存储选手信息，自定义比较规则排序，使用归并排序处理比赛结果。最终，输出排名第Q的选手编号。AC代码通过STL的sort和merge函数实现排序和合并，确保正确输出。
P1309 瑞士轮【归并排序】
王小平
05-19 565
题目链接 题目背景 在双人对决的竞技性比赛，如乒乓球、羽毛球、国际象棋中，最常见的赛制是淘汰赛和循环赛。前者的特点是比赛场数少，每场都紧张刺激，但偶然性较高。后者的特点是较为公平，偶然性较低，但比赛过程往往十分冗长。 本题中介绍的瑞士轮赛制，因最早使用于1895年在瑞士举办的国际象棋比赛而得名。它可以看作是淘汰赛与循环赛的折中，既保证了比赛的稳定性，又能使赛程不至于过长。 题目描述 2*...
P1309 [NOIP2011 普及组] 瑞士轮——归并排序
m0_63410759的博客
07-10 213
在双人对决的竞技性比赛，如乒乓球、羽毛球、国际象棋中，最常见的赛制是淘汰赛和循环赛。前者的特点是比赛场数少，每场都紧张刺激，但偶然性较高。后者的特点是较为公平，偶然性较低，但比赛过程往往十分冗长。本题中介绍的瑞士轮赛制，因最早使用于1895 18951895年在瑞士举办的国际象棋比赛而得名。它可以看作是淘汰赛与循环赛的折中，既保证了比赛的稳定性，又能使赛程不至于过长。
c++瑞士轮
Yoyo的博客
01-15 533
每轮比赛的对阵安排与该轮比赛开始前的排名有关：第 1 名和第 2 名、第 3 名和第 4 名、……, w_2N，每两个数之间用一个空格隔开，其中 w_i 表示编号为 i 的选手的实力值。输入的第一行是三个正整数 N、R、Q，每两个数之间用一个空格隔开，表示有 2*N 名选手、R 轮比赛，以及我们关心的名次 Q。对于 100%的数据，1 ≤ N ≤ 100,000，1 ≤ R≤ 50，1 ≤ Q ≤ 2N，输出只有一行，包含一个整数，即 R 轮比赛结束后，排名第 Q 的选手的编号。
P1309 瑞士轮(C++)
ccql's Blog
01-15 3091
题目背景 在双人对决的竞技性比赛，如乒乓球、羽毛球、国际象棋中，最常见的赛制是淘汰赛和循环赛。前者的特点是比赛场数少，每场都紧张刺激，但偶然性较高。后者的特点是较为公平，偶然性较低，但比赛过程往往十分冗长。 本题中介绍的瑞士轮赛制，因最早使用于1895年在瑞士举办的国际象棋比赛而得名。它可以看作是淘汰赛与循环赛的折中，既保证了比赛的稳定性，又能使赛程不至于过长。 题目描述 2×N 名编号为 1∼2...
C++算法题——洛谷P1309瑞士轮(BUG 待更)
Xyg's LearningSpace
11-11 765
问题：时间复杂度过高。 解决方案：设置A、B两个数组分别存储赢与输的两组，组内顺序不变，最后用merge合并。 待改，待更，欢迎交流。 #include #include using namespace std; int main(){ int N,R,Q; int numQ,keyQ; int size = 0; cin &gt;&gt; N &gt;&gt; R &gt;&gt; Q; k...
c++洛谷P1309 [NOIP2011 普及组] 瑞士轮
Yoyo的博客
08-23 420
在双人对决的竞技性比赛，如乒乓球、羽毛球、国际象棋中，最常见的赛制是淘汰赛和循环赛。前者的特点是比赛场数少，每场都紧张刺激，但偶然性较高。后者的特点是较为公平，偶然性较低，但比赛过程往往十分冗长。本题中介绍的瑞士轮赛制，因最早使用于18951895年在瑞士举办的国际象棋比赛而得名。它可以看作是淘汰赛与循环赛的折中，既保证了比赛的稳定性，又能使赛程不至于过长。
P1309 [NOIP 2011 普及组] 瑞士轮 java实现
03-18
### 解决方案 #### 背景说明 瑞士轮赛制是一种特殊的竞赛机制，其核心在于通过多轮比较调整选手排名。题目要求模拟这一过程，并最终输出每位选手的成绩排序[^2]。 为了高效解决问题，在算法设计上可以借鉴C++中的优化思路：先利用快速排序对初始数据进行预处理，随后在每一轮比赛中分别维护胜者组和败者组的顺序关系，并通过归并排序的方式合并两组数据[^3]。这种方法能够显著降低时间复杂度至 \(O(N \cdot (R + \log N))\) ，其中 \(N\) 是参赛人数，\(R\) 是总轮数。 以下是基于上述逻辑的 Java 实现： --- #### Java 实现代码 ```java import java.util.*; public class Main { static class Contestant implements Comparable<Contestant> { int score; // 当前得分 int initialOrder; // 初始编号 public Contestant(int score, int initialOrder) { this.score = score; this.initialOrder = initialOrder; } @Override public int compareTo(Contestant other) { if (this.score != other.score) { return Integer.compare(other.score, this.score); // 按分数降序排列 } return Integer.compare(this.initialOrder, other.initialOrder); // 同分按初始编号升序排列 } } public static void main(String[] args) { Scanner sc = new Scanner(System.in); // 输入参数 R 和 N int R = sc.nextInt(); // 总轮数 int N = sc.nextInt(); // 参赛人数 List<Contestant> contestants = new ArrayList<>(); // 初始化选手列表 for (int i = 0; i < N; i++) { int s_i = sc.nextInt(); contestants.add(new Contestant(s_i, i + 1)); } // 对初始状态进行排序 Collections.sort(contestants); // 开始模拟每一场比赛 for (int round = 0; round < R; round++) { List<Contestant> winners = new ArrayList<>(); // 存储本轮胜者 List<Contestant> losers = new ArrayList<>(); // 存储本轮败者 for (int i = 0; i < N / 2; i++) { // 配对比赛 Contestant A = contestants.get(i * 2); Contestant B = contestants.get(i * 2 + 1); if (A.score >= B.score) { A.score += B.score; winners.add(A); losers.add(B); } else { B.score += A.score; winners.add(B); losers.add(A); } } // 使用归并排序方式重新整理胜者组和败者组 mergeSort(winners, losers, contestants); } // 输出结果 StringBuilder sb = new StringBuilder(); for (Contestant contestant : contestants) { sb.append(contestant.score).append("\n"); } System.out.print(sb.toString()); } private static void mergeSort(List<Contestant> winners, List<Contestant> losers, List<Contestant> result) { int i = 0, j = 0, k = 0; while (i < winners.size() && j < losers.size()) { if (winners.get(i).compareTo(losers.get(j)) <= 0) { result.set(k++, winners.get(i++)); } else { result.set(k++, losers.get(j++)); } } while (i < winners.size()) { result.set(k++, winners.get(i++)); } while (j < losers.size()) { result.set(k++, losers.get(j++)); } } } ``` --- #### 关键点解析 1. **自定义类 `Contestant`** 定义了一个表示选手的类，包含当前得分 (`score`) 和初始编号 (`initialOrder`) 属性。重写了 `Comparable` 接口以便支持按照特定规则排序：优先依据分数降序排列；同分情况下则按初始编号升序排列。 2. **初始化与初步排序** 将输入数据封装成 `Contestant` 类型对象存入集合中，并调用 `Collections.sort()` 方法完成首次全局排序操作[^4]。 3. **逐轮配对计算** 每次迭代均需遍历整个序列的一半长度来进行一对一较量。获胜方会将其对手原有积分累加到自己身上，同时被分配进入不同的子集——即胜利阵营或失败阵营。 4. **归并重组策略** 借助辅助方法 `mergeSort()` 把分离后的两个部分再次融合回单一整体结构之中，从而保持总体秩序稳定的同时达到线性时间开销的效果。 --- #### 时间与空间复杂度分析 - **时间复杂度**: 主要是前期准备阶段涉及了一次完整的数组扫描以及后续每次更新时执行的局部调整动作。因此综合来看大约等于 \(O(N\cdot(\log{N}+R))\)。 - **空间复杂度**: 整体额外消耗维持在一个固定范围内，约为 \(O(N)\)，主要用于暂存中间过渡成果的数据容器之上。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值