[CSP-S 2024] 擂台游戏满分代码

最新推荐文章于 2025-07-23 22:59:22 发布

原创最新推荐文章于 2025-07-23 22:59:22 发布 · 1k 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#算法

CSP c++ 专栏收录该内容

4 篇文章

订阅专栏

# [CSP-S 2024] 擂台游戏

## 题目描述

小 S 想要举办一场擂台游戏，如果共有 $2^k$ 名选手参加，那么游戏分为 $k$ 轮进行：

- 第一轮编号为 $1, 2$ 的选手进行一次对局，编号为 $3, 4$ 的选手进行一次对局，以此类推，编号为 $2^k - 1, 2^k$ 的选手进行一次对局。
- 第二轮在只保留第一轮的胜者的前提下，相邻的两位依次进行一场对局。
- 以此类推，第 $k - 1$ 轮在只保留第 $k - 2$ 轮的 $4$ 位胜者的前提下，前两位、后两位分别进行对局，也就是所谓的半决赛。
- 第 $k$ 轮即为半决赛两位胜者的决赛。

确定了游戏晋级的规则后，小 S 将比赛的规则设置为了擂台赛。具体而言，每位选手都有一个能力值 $a_1, a_2, \dots , a_{2^k}$，能力值为 $[0,2^{31}-1]$ 之内的整数。对于每场比赛，会先抽签决定一个数 $0/1$，我们将第 $R$ 轮的第 $G$ 场比赛抽到的数记为 $d_{R,G}$。抽到 $0$ 则表示表示编号小的选手为擂主，抽到 $1$ 则表示编号大的选手为擂主。擂主获胜当且仅当他的能力值 $a\geq R$。也就是说，游戏的胜负只取决于**擂主的能力值**与**当前比赛是第几轮**的大小关系，**与另一位的能力值无关**。

现在，小 S 先后陆续收到了 $n$ 位选手的报名信息，他们分别告知了小 S 自己的能力值。小 S 会按照报名的先后顺序对选手进行编号为 $1, 2, \dots, n$。小 S 关心的是，补充**尽量少**的选手使总人数为 $2$ 的整次幂，且所有选手进行一次完整的擂台游戏后，所有可能成为总冠军的选手的**编号之和**是多少。

形式化地，设 $k$ 是最小的非负整数使得 $2^k\geq n$，那么应当补充 $(2^k-n)$ 名选手，且补充的选手的能力值可以任取 $[0,2^{31}-1]$ 之内的整数。**如果补充的选手有可能取胜，也应当计入答案中**。

当然小 S 觉得这个问题还是太简单了，所以他给了你 $m$ 个询问 $c_1,c_2,\dots,c_m$。小 S 希望你帮忙对于每个 $c_i$ 求出，在只收到前 $c_i$ 位选手的报名信息时，这个问题的答案是多少。

## 输入格式

**本题的测试点包含有多组测试数据。** 但不同测试数据只是通过修改 $a_1, a_2, \dots , a_n$ 得到，其他内容均保持不变，请参考以下格式。其中 $\oplus$ 代表异或运算符，$a \bmod b$ 代表 $a$ 除以 $b$ 的余数。

输入的第一行包含两个正整数 $n, m$，表示报名的选手数量和询问的数量。

输入的第二行包含 $n$ 个非负整数 $a'_1,a'_2,\dots,a'_n$，这列数将用来计算真正的能力值。

输入的第三行包含 $m$ 个正整数 $c_1, c_2, \dots , c_m$，表示询问。

设 $K$ 是使得 $2^K \geq n$ 的最小的非负整数，接下来的 $K$ 行当中，第 $R$ 行包含 $2^{K-R}$ 个数（无空格），其中第 $G$ 个数表示第 $R$ 轮的第 $G$ 场比赛抽签得到的 $d_{R,G}=0/1$。

注意，由于询问只是将人数凑齐到 $2^k\geq c_i$，这里的 $k\leq K$，因此你未必会用到全部的输入值。

接下来一行包含一个正整数 $T$，表示有 $T$ 组测试数据。

接下来共 $T$ 行，每行描述一组数据，包含 $4$ 个非负整数 $X_0,X_1,X_2,X_3$，该组数据的能力值 $a_i=a'_i \oplus X_{i\bmod 4}$，其中 $1\leq i\leq n$。

## 输出格式

共输出 $T$ 行，对于每组数据，设 $A_i$ 为第 $i$（$1 \leq i \leq m$）组询问的答案，你只需要输出一行包含一个整数，表示 $(1\times A_1) \oplus (2\times A_2) \oplus \dots \oplus (m\times A_m)$ 的结果。

## 样例 #1

### 样例输入 #1

```
5 5
0 0 0 0 0
5 4 1 2 3
1001
10
1
4
2 1 0 0
1 2 1 0
0 2 3 1
2 2 0 1
```

### 样例输出 #1

```
5
19
7
1
```

## 提示

**【样例 1 解释】**

共有 $T = 4$ 组数据，这里只解释第一组。$5$ 名选手的真实能力值为 $[1, 0, 0, 2, 1]$。$5$ 组询问分别是对长度为 $5, 4, 1, 2, 3$ 的前缀进行的。

1. 对于长度为 $1$ 的前缀，由于只有 $1$ 号一个人，因此答案为 $1$。
2. 对于长度为 $2$ 的前缀，由于 $2$ 个人已经是 $2$ 的幂次，因此不需要进行扩充。根据抽签 $d_{1,1} = 1$ 可知 $2$ 号为擂主，由于 $a_2 < 1$，因此 $1$ 号获胜，答案为 $1$。
3. 对于长度为 $3$ 的前缀，首先 $1$ 号、$2$ 号比赛是 $1$ 号获胜（因为 $d_{1,1} = 1$，故 $2$ 号为擂主，$a_2 < 1$），然后虽然 $4$ 号能力值还不知道，但 $3$ 号、$4$ 号比赛一定是 $4$ 号获胜（因为 $d_{1,2} = 0$，故 $3$ 号为擂主，$a_3 < 1$），而决赛 $1$ 号、$4$ 号谁获胜都有可能（因为 $d_{2,1} = 1$，故 $4$ 号为擂主，如果 $a_4 < 2$ 则 $1$ 号获胜，$a_4 \geq 2$ 则 $4$ 号获胜）。综上所述，答案为 $1 + 4 = 5$。
4. 对于长度为 $4$ 的前缀，我们根据上一条的分析得知，由于 $a_4 \geq 2$ ，所以决赛获胜的是 $4$ 号。
5. 对于长度为 $5$ 的前缀，可以证明，可能获胜的选手包括 $4$ 号、$7$ 号、$8$ 号，答案为 $19$。

因此，该组测试数据的答案为 $(1 \times 19) \oplus (2 \times 4) \oplus (3 \times 1) \oplus (4 \times 1) \oplus (5 \times 5) = 5$。

**【样例 2】**

见选手目录下的 arena/arena2.in 与 arena/arena2.ans。

这组样例满足特殊性质 A。

**【样例 3】**

见选手目录下的 arena/arena3.in 与 arena/arena3.ans。

这组样例满足特殊性质 B。

**【样例 4】**

见选手目录下的 arena/arena4.in 与 arena/arena4.ans。

**【样例 5】**

见选手目录下的 arena/arena5.in 与 arena/arena5.ans。

**【数据范围】**

对于所有测试数据，保证：$2 \leq n, m \leq 10^5$，$0 \leq a_i, X_j < 2^{31}$，$1 \leq c_i \leq n$，$1 \leq T \leq 256$。

| 测试点 | $T=$ | $n,m\leq$ | 特殊性质 A | 特殊性质 B |
| :----------: | :----------: | :----------: | :----------: | :----------: |
| $1\sim 3$ | $1$ | $8$ | 否 | 否 |
| $4,5$ | $1$ | $500$ | 是 | 否 |
| $6\sim 8$ | $1$ | $500$ | 否 | 是 |
| $9,10$ | $1$ | $5000$ | 否 | 否 |
| $11,12$ | $1$ | $10^5$ | 是 | 否 |
| $13\sim 15$ | $1$ | $10^5$ | 否 | 是 |
| $16,17$ | $4$ | $10^5$ | 否 | 否 |
| $18,19$ | $16$ | $10^5$ | 否 | 否 |
| $20,21$ | $64$ | $10^5$ | 否 | 否 |
| $22,23$ | $128$ | $10^5$ | 否 | 否 |
| $24,25$ | $256$ | $10^5$ | 否 | 否 |

特殊性质 A：保证询问的 $c_i$ 均为 $2$ 的幂次。

特殊性质 B：保证所有的 $d_{R,G} = 0$。

#include <cstdio>
#include <algorithm>
using namespace std; 
inline int read(){
	char c = getchar();
	while(c<48||c>57) c=getchar();
	int x = 0;
	while(48<=c&&c<=57){
		x = (x<<3)+(x<<1)+c-48;
		c = getchar();
	}
	return x;
}
typedef long long int64;
// 深度 x+1 的前缀，dpref(x)+i 为深度 x 中排行 i 的结点编号 
#define dpref(x) ((1<<(x))-1)
// 深度 x+1 的结点数 
#define dsize(x) (1<<(x))
#define fa(x) ((x)>>1)
#define ls(x) ((x)<<1)
#define rs(x) ((x)<<1|1)
#define bro(x) ((x)^1)
// x 是左(0)/右(1)子树 
#define lr(x) ((x)&1)

int n, m, a[100001], c[100001];
int K, d[131072];
int T, X[4]; 

void init();
void solve();

int main(){
	n = read(); m = read();
	for(K=1; (1<<K)<n; ++K);
	for(int i=1; i<=n; ++i) a[i] = read();
	for(int i=1; i<=m; ++i){
		c[i] = read();
	}
	char buffer[65537];
	for(int R=1; R<=K; ++R){
		scanf("%s", buffer);
		for(int G=1; G<=dsize(K-R); ++G){
			d[dpref(K-R)+G] = buffer[G-1]=='1';
		}
	}
	
	init();
	
	T = read();
	while(T--){
		for(int i=0; i<4; ++i) X[i] = read();
		for(int i=1; i<=n; ++i) a[i] ^= X[i%4];
		solve();
		// 技巧: 异或运算的自逆性 (a^b)^b = a 
		for(int i=1; i<=n; ++i) a[i] ^= X[i%4];
	}
	return 0;
}


// maxround[i][j] ~ 选手 i 的实力为 j 时，满足条件 1 的最大轮数 
int maxround[100001][17];
// cround[i] ~ i 对应的比赛结点的轮数(r)
int cround[262144];
// 获胜的 c 上界(s) 
int ceiling[262144];
// 获胜者能力值(p) 
int power[262144];
// larray[i] 即 i 对应的 l 值，预处理降常 
int larray[131073];

// 模拟法求 maxround ，复杂度 O(nlogn) 
void make_maxround(){
	for(int i=1; i<=n; ++i){
		for(int j=0; j<K; ++j){
			maxround[i][j] = K;
		}
		int curr = dpref(K)+i;
		int competion = fa(curr);
		// 双指针，即使不用，写成 O(n(logn)^2) 也是可以接受的 
		int p = 0;
		for(int round=1; round<=K; ++round){
			if(d[competion]==lr(curr)){
				for(int j=p; j<round; ++j){
					maxround[i][j] = round-1;
				}
				p = round;
			}
			curr = competion;
			competion = fa(curr);
		}
	}
}
// 求 cround ，复杂度 O(n)
void make_cround(int id, int round){
	cround[id] = round;
	if(id<=dpref(K)){
		make_cround(ls(id), round-1);
		make_cround(rs(id), round-1);
	}
}
void make_larray(){
	// 注意，i=1 时 ， l=1 
	larray[1] = 1;
	for(int i=2; i<=(1<<K); ++i){
		int l = 1;
		if(i!=1){
			for(; l<i; l<<=1);
			l = (l>>1)+1;
		}
		larray[i] = l;
	}
}
void init(){
	make_maxround();
	make_cround(1, K);
	make_larray();
}

// 重置 ceiling(s), power(p)
void clear(int id){
	ceiling[id] = n;
	power[id] = -1;
	if(id<=dpref(K)){
		clear(ls(id));
		clear(rs(id));
	}
}

// 更新 power[id] 后计算影响 
void update(int id, int time){
	if(id==1) return;
	// 注意不要遗漏能确定 power(fa[id]) 的情况 
	if(d[fa(id)]==lr(id)){
		if(power[id]>=cround[fa(id)]){
			ceiling[bro(id)] = min(ceiling[bro(id)], time-1);
			power[fa(id)] = power[id];
			update(fa(id), time);
		}else if(power[bro(id)]!=-1){
			power[fa(id)] = power[bro(id)];
			update(fa(id), time);
		}
	}else if(power[bro(id)]!=-1 && power[bro(id)]<cround[fa(id)]){
		power[fa(id)] = power[id];
		update(fa(id), time);
	}
}
// 向下传递 ceiling 
void push_down(int id){
	if(id<=dpref(K)){
		ceiling[ls(id)] = min(ceiling[ls(id)], ceiling[id]);
		ceiling[rs(id)] = min(ceiling[rs(id)], ceiling[id]);
		push_down(ls(id));
		push_down(rs(id));
	}
}

int64 result[100002];
void solve(){
	clear(1);
	for(int i=1; i<=n; ++i){
		power[dpref(K)+i] = a[i];
		update(dpref(K)+i, i);
		// 注意 result 差分数组也要清空 
		result[i] = 0;
	}
	push_down(1);
	for(int i=1; i<=dsize(K); ++i){
		int l = larray[i];
		// 条件 2 
		int r = ceiling[dpref(K)+i];
		// 条件 1 ，注意前提是 a[i] 是确定的值，a[i]>=K 时不会限制 
		if(i<=n && r>=i && a[i]<K){
			// min(r) 是必要的，条件 1 限制的上界可能大于条件 2 限制的上界 
			r = min(r, 1<<maxround[i][a[i]]);
			// 注意，当且仅当 r>=i 时才能用条件 1 限制 r ，应该 min(i-1) 修正 
			r = max(r, i-1);
		}
		if(r>=l){
			result[l] += i;
			result[r+1] -= i;
		}
	}
	for(int i=1; i<=n; ++i){
		result[i] += result[i-1];
	}
	int64 ans = 0;
	for(int i=1; i<=m; ++i){
		ans ^= result[c[i]]*i;
	}
	printf("%lld\n", ans);
}