CF1511G Chips on a Board (倍增)
题面
转化方便版题意:
有 n n n 堆石子,第 i i i 堆有 c i ∈ [ 1 , m ] c_i\in [1,m] ci∈[1,m] 个石子,有 q q q 次询问,每次询问给出 L i , R i L_i,R_i Li,Ri ,先把 c i ∉ [ L i , R i ] c_i\not\in [L_i,R_i] ci∈[Li,Ri] 的石堆都扔掉,然后把每堆石子减少 L i L_i Li 个,最后用剩下的若干堆石子做 N i m Nim Nim 游戏,先手必胜输出 A \tt A A ,后手必胜输出 B \tt B B 。
1 ≤ n , m , q ≤ 2 ⋅ 1 0 5 1\leq n,m,q\leq2\cdot10^5 1≤n,m,q≤2⋅105.
题解
官方题解,是 O ( N N log N ) O(N\sqrt{N\log N}) O(NNlogN) 的做法。
对每个询问暴力求解,是 O ( N 2 ) O(N^2) O(N2) 的。或者,如果记录每一种 c i c_i ci 值的出现次数的话,也可以是 O ( N M ) O(NM) O(NM) 的。后者可以优化: c i c_i ci 的二进制表示有 18 \tt18 18 位,我们把前面九位和后面九位分开算,这样,分别就只有 2 9 = 512 2^9=512 29=512 种取值,也就是 M \sqrt{M} M 种取值了,这就增加了暴力的可能性。同时,只管前九位和后九位都是能比较方便地处理加减法的,因此这样刚好是可行的,要是分成前六位、中六位、后六位就及其不好做了。
但是,处理后九位数字还是比较麻烦的。而且,这个时间复杂度也不优。
不如看看下面又易懂又好写还在时间复杂度上暴踩官解的做法。
真是妙蛙种子吃着妙脆角,妙进了米奇妙妙屋,妙到家了
真的就不能每一位分开来做了吗?
加减法固然会对二进制表示产生不好计量的影响,但是我们有这么一条很容易发现的结论:
- 若 A < 2 k A<2^k A<2k ,则 A + 2 k = A x o r 2 k A+2^k=A~xor~2^k A+2k=A xor 2k
这种情况下,加法是等同于异或的!
那我们不妨就想个办法,能不能把减法变成加法,然后把要加的部分按位拆分开来,利用上面的结论一步一步异或进去呢?
有!那就是倍增。倍增可以把减法换成加法,而且不难发现,倍增刚好是从高位往低位考虑的,前面要加的数的 lowbit
一定比后面的数都大。
我们定义 f [ i ] [ j ] f[i][j] f[i][j] 为询问 L = i , R = i + 2 j − 1 L=i,R=i+2^j-1 L=i,R=i+2j−1 时的答案,不难发现 f [ i ] [ 0 ] = 0 f[i][0]=0 f[i][0]=0。
计算
f
[
i
]
[
j
]
f[i][j]
f[i][j] 的时候,先异或上
f
[
i
]
[
j
−
1
]
f[i][j-1]
f[i][j−1] ,然后由于
f
[
i
+
2
j
−
1
]
[
j
−
1
]
f[i+2^{j-1}][j-1]
f[i+2j−1][j−1] 中的每堆石子个数
<
2
j
−
1
< 2^{j-1}
<2j−1 ,我们把这些石堆加上
2
j
−
1
2^{j-1}
2j−1 时,等价于异或
2
j
−
1
2^{j-1}
2j−1,因此我们只需要再知道
[
i
+
2
j
−
1
,
i
+
2
j
−
1
]
[i+2^{j-1},i+2^j-1]
[i+2j−1,i+2j−1] 区间之内石堆的个数,就可以转移了。令
c
t
[
i
]
[
j
]
ct[i][j]
ct[i][j] 表示
c
i
∈
[
i
,
i
+
2
j
−
1
]
c_i\in[i,i+2^j-1]
ci∈[i,i+2j−1] 的石堆的个数,则:
f
[
i
]
[
j
]
=
f
[
i
]
[
j
−
1
]
x
o
r
f
[
i
+
2
j
−
1
]
[
j
−
1
]
x
o
r
(
2
j
−
1
⋅
(
c
t
[
i
+
2
j
−
1
]
[
j
−
1
]
%
2
)
)
c
t
[
i
]
[
j
]
=
c
t
[
i
]
[
j
−
1
]
+
c
t
[
i
+
2
j
−
1
]
[
j
−
1
]
f[i][j]=f[i][j-1]~{\tt xor}~f[i+2^{j-1}][j-1]~{\tt xor}~\Big( 2^{j-1}\cdot(ct[i+2^{j-1}][j-1]\,\%\,2) \Big)\\ ct[i][j]=ct[i][j-1]+ct[i+2^{j-1}][j-1]
f[i][j]=f[i][j−1] xor f[i+2j−1][j−1] xor (2j−1⋅(ct[i+2j−1][j−1]%2))ct[i][j]=ct[i][j−1]+ct[i+2j−1][j−1]
询问的时候,类似的。由于是倍增,每次访问到的 f [ i ] [ j ] f[i][j] f[i][j] 的 j j j 都会变小,也就是说它所代表的这个区间内的石堆 c i c_i ci 都小于先前的 2 j 2^j 2j ,都可以把加法换成异或,再通过 c t [ i ] [ j ] ct[i][j] ct[i][j] 补到 f [ i ] [ j ] f[i][j] f[i][j] 中。
代码也很好理解,基本是标准的预处理倍增。时间复杂度只有 O ( N log N ) O(N\log N) O(NlogN) 。
CODE
比解说还短的倍增代码
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define MAXN 200005
#define ENDL putchar('\n')
#define LL long long
#define DB double
#define lowbit(x) ((-x) & (x))
LL read() {
LL f = 1,x = 0;char s = getchar();
while(s < '0' || s > '9') {if(s=='-')f = -f;s = getchar();}
while(s >= '0' && s <= '9') {x=x*10+(s-'0');s = getchar();}
return f * x;
}
int n,m,i,j,s,o,k;
int c[MAXN],dp[MAXN][20],ct[MAXN][20];
int main() {
// Input
n = read();m = read();
for(int i = 1;i <= n;i ++)
c[i] = read(),ct[c[i]][0] ++;
// Init
for(int i = m;i > 0;i --) {
for(int j = 1;i+(1<<j)-1 <= m;j ++) {
ct[i][j] = ct[i][j-1] + ct[i+(1<<(j-1))][j-1];
dp[i][j] = dp[i][j-1] ^ dp[i+(1<<(j-1))][j-1] ^ ((ct[i+(1<<(j-1))][j-1] & 1) ? (1<<(j-1)):0);
}
}
// Query
int q = read();
while(q --) {
s = read();o = read();
int xr = 0,as = 0;
for(int j = 18;j >= 0;j --) {
if(s+(1<<j)-1 <= o) {
as ^= dp[s][j]^((ct[s][j] & 1) ? xr:0);
xr ^= (1<<j); s += (1<<j);
}
}
printf(as ? "A":"B");
}
return 0;
}