P5652 基础博弈练习题

题目链接：P5652 基础博弈练习题

算法分析

题目很有思考价值。博弈论的题目大多需要绕来绕去。

题意中，如果一方走到了$i$，那么另一方只能在区间$[i,max(i+m,n)]$之间走。假设序列b长度为1，此时该列为偶数的话，先手必胜；否则，先手必败。如果序列b长度为2，很容易想到，假设最后一列长度为奇数，谁先走到最后一列，谁胜；如果最后一列长度为偶数，谁先走到最后一列，谁败。

依次类推，我们需要考虑最后一列的奇偶性。用必胜态和必败态进行描述，指的都是先手。假设此时最后一列是第$i$列。

若$a[i]$是奇数，谁先到达该列谁胜，是必胜态，则$[i-m,i-1]$是必败态，谁先到谁输。双方都会争取留在第$i-m-1$列上。此时需要判别第$i-m-1$列的奇偶性。

若$a[i]$是偶数，谁先到达该列谁输，是必败态，双方都会争取留在第$i-1$列，此时需要判别第$i-1$列的奇偶性。

因此，从后往前推，可以通过判别某列的奇偶性，找到必胜态。设$pre[i]$表示第$i$列之前最近的必胜态是哪一列。可以有：

若$a[i]$是奇数，如果$a[i-m-1]$是奇数，则$pre[i]=i-m-1$，否则$pre[i]=pre[i-m-1]$

若$a[i]$是偶数，如果$a[i-1]$是奇数，则$pre[i]=i-1$，否则$pre[i]=pre[i-1]$

对于区间$[l,r]$，如果必胜局面是怎么样的？可以考虑以上两种形态。上面的形态都是必胜态转向必胜态，注意，必胜态中间是有必败态的。下面的形态中最后由必胜态转向必败态，中间没有其他形态，是直接转向的。先手在必胜态，然后紧接着到了后手，后手面临必败态。

那么什么情况下区间$[l,r]$不是必胜局面呢？当$l$无法转向$r$时必败。

这时，我们就很自然的建树。$(pre[i],i)$是一条边。发现这其实是个森林，我们可以让没有pre的点都指向0结点，这样就形成了一棵以0为根结点的树。在这棵树中，如果$l$是$r$的祖先结点，那么先手必胜。

用时间戳即可判定。如果满足$dfn[l]<=dfn[r]<=dfn[l]+size[l]-1$成立，则$l$是$r$的祖先结点。

在最初放置在$l$位置的时候，$a[l]$要减1，这意味着可以看做先手减1，判断是否后手必胜。结合树结构来理解，即$l$这个位置一定要操作，否则就无法确定区间的左端点了，因此最初减1是很必要的，如果不减1，题意就根本性变化了。

在树上判断$[l,r]$的父子关系，前提是$l<r$，如果$l=r$呢？这个需要特判。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define ll long long
const ll Mod = 1LL << 32;  // 注意  
int n, m, q, type, a[1000010], pre[1000010], dfn[1000010], tot, szsize[1000010];
int h[1000010], cnt;
int A, B, C, P;
struct node
{
	int next, to;
}edg[1000010];
inline void add(int u, int v)
{
	++cnt;
	edg[cnt].next = h[u];
	edg[cnt].to = v;
	h[u] = cnt;
}
inline int szread()
{
	int x = 0, f = 1; char c = getchar();
	while (c < '0' || c > '9')
	{
		if (c == '-') f = -1;
		c = getchar();
	}
	while (c >= '0' && c <= '9')
	{
		x = x * 10 + c - '0';
		c = getchar();
	}
	return x * f;
}
void dfs(int u)
{
	dfn[u] = ++tot;
	for (int i = h[u]; i; i = edg[i].next)
		dfs(edg[i].to);
}
void dfs_size(int u)
{
	szsize[u] = 1;
	for (int i = h[u]; i; i = edg[i].next)
	{
		dfs_size(edg[i].to);
		szsize[u] += szsize[edg[i].to];
	}
}
inline int rnd()
{
	return A = (A * B + C) % P;
}
int szquery(int l, int r)
{
	if (dfn[l] <= dfn[r] && dfn[r] <= dfn[l] + szsize[l] - 1) return 1;
	else return 0;
}
int main()   
{
	n = szread(); m = szread(); q = szread(); type = szread();
	for (int i = 1; i <= n; ++i) a[i] = szread(), a[i] &= 1;
	for (int i = 1; i <= n; ++i)
	{
		if (a[i]) // 奇数 
		{
			if (i - m - 1 >= 1)
			{
				if (a[i-m-1]) pre[i] = i - m - 1;
				else pre[i] = pre[i-m-1];
			}
			else pre[i] = 0;
		}else  // 偶数  
		{
			if (a[i-1]) pre[i] = i - 1;
			else pre[i] = pre[i-1];
		}
	}
	// 建树 0号点是根节点 
	for (int i = 1; i <= n; ++i)
		add(pre[i], i); 
		
	dfs(0); // 记录每个点第一次被访问时的时间戳dfn  
	dfs_size(0); // 记录子树大小  
	int l, r, ansi;
	ll ans = 0;
	if (type)
	{
		A = szread(); B = szread(); C = szread(); P = szread();
	}
	for (int i = 1; i <= q; ++i)
	{
		if (type)
		{
			l = rnd() % n + 1; r = rnd() % n + 1;
			if (l > r) swap(l, r);
		}else
		{
			l = szread(); r = szread();
		}
		if (l == r)  // 重要  
		{
			if (a[l]) ansi = 0; else ansi = 1;
		}else
		{
			if (!szquery(l, r)) ansi = 1; else ansi = 0;
		}		
		ans += ((ll)i * i * ansi) % Mod;
	}
	printf("%lld\n", ans % Mod);
	return 0;
}

反思与总结

1. $2^{32}$超过了$int$，因此宏定义时要$constllMod=1LL<<32$，1后面的$LL$是转换为long long的意思，没有这部转化，会错误。

2. 链式前向星存图效率还是很高的，对比vector存图，时间和空间有明显的优化。

3. 开long long，一般不会卡常。但是不需要开的时候，最好还是不开。

4. 推博弈论的题目，要从最简单和一般的情形开始，然后导出必胜态和必败态。