@NOI模拟2017.06.30

@description@
@solution@
- @part - 1@
- @part - 2@
@accepted code@
@details@

@description@

JOHNKRAM 和 C_SUNSHINE 在玩一个游戏。

游戏规则如下：有若干堆石子，游戏前选定一个正整数 p，JOHNKRAM 先手，两个人轮流操作。定义一次操作是选择某一堆石子，然后拿出其中的 p^k(k∈N) 个石子扔掉，不能操作者输。

C_SUNSHINE 表示判定谁能赢太简单了，于是他放了 n 堆石子，编号为 1∼n。

他每次把编号在某个区间内的石子堆加上若干个石子，或者询问以编号在某个区间内的石子堆进行游戏，是谁胜利。

JOHNKRAM 表示他不会做，于是他来向你求助。

input

第一行三个数 n, q, p，n 表示序列的长度，q 表示接下来操作的次数，p 的意义如题目描述中所说。

接下来一行 n 个数，第 i 个数表示初始时第 i 堆石子的石子数量。

接下来 q 行每行第一个数t表示操作类型，t=0 表示修改，t=1 表示询问。

对于一个修改操作，该行还会有三个数 l, r, x，表示把 [l…r] 的所有石子堆加上 x 个石子（博主注：x 为正数且属于 int 范围）。

对于一个询问操作，该行还会有两个数 l, r，表示询问以 [l…r] 的所有石子堆进行游戏是谁胜。

保证 1 <= n, q, p, 每堆石子的初始数量 <= 10^5。

output

对于每一个询问，如果 JOHNKRAM 胜利输出 1，否则输出 0。

sample input

10 9 3

2 6 2 5 8 7 4 3 4 1

1 1 10

0 5 7 15

1 1 3

0 3 9 11

1 3 7

0 4 5 53

0 1 2 26

1 6 10

1 4

sample output

0

0

0

1

0

@solution@

@part - 1@

通过对sg函数打表简单推导可得：

（1）当 p 为奇数时，sg函数循环节长度为 2，循环节为 01。即：

当 x % 2 == 0 时，sg[x] = 0。

当 x % 2 == 1 时，sg[x] = 1。

（2）当 p 为偶数时，sg函数循环节长度为 (p+1)，循环节为 010101……01012。即：

当 x % (p+1) == p 时，sg[x] = 2。

当 (x % (p+1)) % 2 == 1 时，sg[x] = 1。

当 x % (p+1) != p 且 (x % (p+1)) % 2 == 0 时，sg[x] = 0。

简要（感性地）证明一下吧：

首先我们可以发现，当 x < p 时，只能从 sg[x-1] 到 sg[x]，故一定形如 010101……

当 p 为奇数时，p^k 肯定也为奇数，即我们总是只能从偶数转移到奇数，奇数转移到偶数，故只能是 010101……

当 p 为偶数时，可以发现 p^k = (-1)^k (mod p+1)，于是我们可以在 mod p+1 的意义下从 x+1 与 x-1 转移到 x。故当 x % (p+1) == p 时，sg[x] 只能等于 2。

于是可以得证。

@part - 2@

根据 sg 函数应用于博弈论的结论，我们必须在询问时求出区间 [l, r] 中 sg 函数的异或和才能判定胜负。

奇数很好办，写一个支持区间反转，统计区间中 1 的个数的线段树即可。

考虑偶数。我们需要在支持模意义下区间加操作时，至少可以询问一个区间内值等于 p 的个数（即 sg[x] = 2 的个数）。

我不知道线段树能不能搞。这显然是分块来搞。修改时整块加法标记，散块暴力重构；查询时整块通过加法标记寻找，散块暴力遍历。

再考虑求出一个区间内值为奇数的个数（即 sg[x] = 1 的个数）。考虑重构时储存值为奇数与值为偶数的两个有序数列，这样整块在加法标记下，新奇数序列必然是原奇数序列的某后缀接上原偶数序列的某前缀，或反过来原偶数序列的某后缀接上原奇数序列的某前缀。新偶数序列同理。

于是我们根据加法标记二分查找一下，就可以求出 sg[x] = 1 的个数了。

显然奇数也可以分块来搞，所以我们就可以不用写线段树了。

总复杂度 O(nsqrt(n)log n)，有些卡但开了O2大概3s能过。

标算给出了一个 O(nsqrt(nlog n)) 的算法，不过太难写了。

大概就是在重构时充分利用原奇偶序列的有序性，归并两个有序数列可以在线性时间内完成，于是可以线性时间完成重构。然后再重新调整块的大小使询问与修改的复杂度平衡。

这个常数说不定还不如上面那个算法……

@accepted code@

#include<cstdio>

#include<algorithm>

using namespace std;

#define lb lower_bound

const int BLOCK = 320;

const int MAXN = 100000;

int le[MAXN/BLOCK + 5], ri[MAXN/BLOCK + 5], add[MAXN/BLOCK + 5], num[MAXN + 5];

int arr[2][MAXN/BLOCK + 5][BLOCK + 5], siz[2][MAXN/BLOCK + 5];

int n, q, p, bcnt;

int a[MAXN + 5];

void rebuild(int x) {

	siz[0][x] = siz[1][x] = 0;

	for(int i=le[x];i<=ri[x];i++)

		arr[a[i]&1][x][++siz[a[i]&1][x]] = a[i];

	sort(arr[0][x] + 1, arr[0][x] + siz[0][x] + 1);

	sort(arr[1][x] + 1, arr[1][x] + siz[1][x] + 1);

}

void build() {

	bcnt = (n-1)/BLOCK + 1;

	for(int i=0;i<n;i++) {

		if( i % BLOCK == 0 )

			le[i/BLOCK+1] = ri[i/BLOCK+1] = i;

		else ri[i/BLOCK+1]++;

		num[i] = i/BLOCK+1;

	}

	for(int i=1;i<=bcnt;i++)

		rebuild(i);

}

void pushdown(int x) {

	for(int i=le[x];i<=ri[x];i++)

		a[i] = (a[i] + add[x])%(p+1);

	add[x] = 0;

}

int fun(int x) {

	if( x == p ) return 2;

	else return (x&1);

}

int main() {

	freopen("right.in", "r", stdin);

	freopen("right.out", "w", stdout);

	scanf("%d%d%d", &n, &q, &p);

	if( p % 2 == 1 ) p = 1;

	for(int i=0;i<n;i++)

		scanf("%d", &a[i]), a[i] %= (p+1);

	build();

	for(int i=1;i<=q;i++) {

		int tp; scanf("%d", &tp);

		if( tp == 0 ) {

			int l, r, x; scanf("%d%d%d", &l, &r, &x), l--, r--, x %= (p+1);

			if( num[l] == num[r] ) {

				pushdown(num[l]);

				for(int i=l;i<=r;i++)

					a[i] = (a[i] + x)%(p+1);

				rebuild(num[l]);

			}

			else {

				for(int i=num[l]+1;i<=num[r]-1;i++)

					add[i] = (add[i] + x)%(p+1);

				pushdown(num[l]);

				for(int i=l;i<=ri[num[l]];i++)

					a[i] = (a[i] + x)%(p+1);

				rebuild(num[l]);

				pushdown(num[r]);

				for(int i=le[num[r]];i<=r;i++)

					a[i] = (a[i] + x)%(p+1);

				rebuild(num[r]);

			}

		}

		else {

			int l, r, ans = 0; scanf("%d%d", &l, &r), l--, r--;

			if( num[l] == num[r] ) {

				for(int i=l;i<=r;i++)

					ans ^= fun((a[i] + add[num[i]])%(p+1));

			}

			else {

				for(int i=l;i<=ri[num[l]];i++)

					ans ^= fun((a[i] + add[num[i]])%(p+1));

				for(int i=le[num[r]];i<=r;i++)

					ans ^= fun((a[i] + add[num[i]])%(p+1));

				for(int i=num[l]+1;i<=num[r]-1;i++) {

					int t1 = p-add[i];

					int x = upper_bound(arr[t1&1][i]+1, arr[t1&1][i]+siz[t1&1][i]+1, t1) - arr[t1&1][i];

					int y = lower_bound(arr[t1&1][i]+1, arr[t1&1][i]+siz[t1&1][i]+1, t1) - arr[t1&1][i];

					int z = upper_bound(arr[t1&1^1][i]+1, arr[t1&1^1][i]+siz[t1&1^1][i]+1, t1) - arr[t1&1^1][i];

					if( (x-y) & 1 ) ans ^= 2;

					if( p != 1 && ((z-1+siz[t1&1][i]-x+1) & 1) ) ans ^= 1;

				}

			}

			puts(ans ? "1" : "0");

		}

	}

}

/*

以下是打表用程序：

#include<cstdio>

const int MAXN = 100;

int sg[MAXN + 5];

bool tag[MAXN + 5];

int main() {

	int p; scanf("%d",Q &p);

	sg[0] = 0;

	for(int i=1;i<=MAXN;i++) {

		for(int j=0;j<=MAXN;j++)

			tag[j] = false;

		tag[sg[i-1]] = true;

		if( p != 1 ) {

			int x = p;

			while( x <= i ) {

				tag[sg[i-x]] = true;

				x *= p;

			}

		}

		for(int j=0;;j++)

			if( !tag[j] ) {

				sg[i] = j;

				break;

			}

	}

	for(int i=0;i<=MAXN;i++)

		printf("%d : %d\n", i, sg[i]);

}

*/

@details@

康复计划 - 9。

当我对博弈论一筹莫展时，旁边的 zxb 大佬小声地提醒我说：“打表”。突然就幡然醒悟了。

这场比赛的 T2 我还没写，因为我还没有理解随机状况下标算时间复杂度怎么来的。以后慢慢填坑（咕咕咕）。