【BZOJ2819】Nim 博弈论+树链剖分

本文介绍了Nim游戏的基本规则及其与树链剖分、线段树结合的代码实现方法。重点阐述了如何利用树链剖分与线段树解决Nim游戏中的状态判断问题,并提供了完整的C++代码实现。

又一道博弈论,先来了解一下Nim游戏~

Nim游戏:一种经典 ICG (Impartial Combinatorial Games)——两个人进行游戏,N堆石子,每回合可以取其中某一堆的任意多个,可以取完,但不可以不取。谁不能取谁输。 我们可以将每一个情况根据是否有必胜策略而分为 N-position(先手必胜)和 P-position(后手必胜),对于一个局面,它是 P-position 当且仅当a^a₂^…^an=0

于是,这道题的代码实现是一个树链剖分的裸题。用线段树维护区间异或和。

树链剖分部分请参看【算法杂谈_02】树链剖分

需要注意的是题目叙述中“这三个点会导致你DFS时爆栈”。

解决办法:

①不用DFS,而改为BFS(代码复杂度++)

用栈模拟DFS(代码复杂度++)

③不要问我这是什么。我是雷锋~

#pragma comment(linker, "/STACK:1024000000,1024000000")
④事实上,这道题根本不用考虑DFS爆系统栈!!!因为真的不会爆!!!

Nim C++代码实现:

#include <cctype>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define lson pos<<1
#define rson pos<<1|1
#define N 500010
int n,m,a[N];
int cnt,head[N],next[2*N],to[2*N];
int now,size[N],deep[N],fa[N],son[N],p_id[N],id_p[N],top[N];
int xort[4*N];
void add(int x,int y)
{
	to[++cnt]=y;
	next[cnt]=head[x];
	head[x]=cnt;
}
void dfs(int x,int d)
{
	size[x]=1;deep[x]=d;
	for(int y,i=head[x];i;i=next[i])
		if((y=to[i])!=fa[x])
		{
			fa[y]=x;
			dfs(y,d+1);
			if(size[y]>size[son[x]])
				son[x]=y;
			size[x]+=size[y];
		}
}
void create(int x,int d)
{
	p_id[x]=++now;id_p[now]=x;
	top[x]=d;
	if(son[x])
		create(son[x],d);
	for(int y,i=head[x];i;i=next[i])
		if((y=to[i])!=fa[x]&&y!=son[x])
			create(y,y);
}
void build(int pos,int l,int r)
{
	if(l==r){ xort[pos]=a[id_p[l]]; return; }
	int mid=(l+r)>>1;
	build(lson,l,mid);
	build(rson,mid+1,r);
	xort[pos]=xort[lson]^xort[rson];
}
void fix(int pos,int l,int r,int x,int y)
{
	if(l==x&&r==x){ xort[pos]=y; return; }
	int mid=(l+r)>>1;
	if(x<=mid)
		fix(lson,l,mid,x,y);
	else fix(rson,mid+1,r,x,y);
	xort[pos]=xort[lson]^xort[rson];
}
int query(int pos,int l,int r,int x,int y)
{
	if(x<=l&&r<=y) return xort[pos];
	int mid=(l+r)>>1;
	if(y<=mid)
		return query(lson,l,mid,x,y);
	if(x>mid)
		return query(rson,mid+1,r,x,y);
	return query(lson,l,mid,x,y)^query(rson,mid+1,r,x,y);
}
int getnim(int x,int y)
{
	int f1=top[x],f2=top[y],re=0;
	while(f1!=f2)
	{
		if(deep[f1]<deep[f2])
			swap(x,y),swap(f1,f2);
		re^=query(1,1,n,p_id[f1],p_id[x]);
		x=fa[f1];
		f1=top[x];
	}
	if(deep[x]>deep[y])
		swap(x,y);
	return re^query(1,1,n,p_id[x],p_id[y]);
}
bool getopt()
{
	char ch;
	while(!isalpha(ch=getchar()));
	return ch=='Q';
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	for(int x,y,i=1;i<n;i++)
		scanf("%d%d",&x,&y),
		add(x,y),add(y,x);
	dfs(1,1);
	create(1,1);
	build(1,1,n);
	cin>>m;
	for(int x,y,i=1;i<=m;i++)
	{
		bool opt=getopt();
		scanf("%d%d",&x,&y);
		if(opt)
			printf("%s",getnim(x,y)?"Yes\n":"No\n");
		else
			fix(1,1,n,p_id[x],y);
	}
	return 0;
}


### 树链剖分的适用场景与使用方法 树链剖分是一种高效的数据结构,用于处理树上的路径查询和修改问题。它通过将树分解为若干条不相交的链来优化复杂度,使得许多原本需要 \(O(n)\) 时间的操作可以在 \(O(\log n)\) 时间内完成[^1]。 #### 1. 树链剖分的核心思想 树链剖分的核心在于将树分割成若干条链,这些链可以拼接成树上的任意路径。常见的树链剖分方法包括重链剖分和长链剖分。其中,重链剖分是最常用的一种方法,其基本原理是:对于每个节点,选择其所有子节点中包含节点数最多的子节点作为重儿子,连接重儿子的边称为重边,由重边构成的链称为重链[^2]。 #### 2. 树链剖分的适用场景 树链剖分适用于以下场景: - **路径查询**:例如,求解树上两点之间的最大值、最小值或和等问题。 - **路径修改**:例如,对树上某条路径上的所有节点进行加法或乘法操作。 - **子树查询**:例如,求解某个节点的子树中的最大值、最小值或和等问题。 - **动态维护**:当树的结构或节点属性发生变化时,树链剖分结合线段树等数据结构可以高效地维护这些变化。 #### 3. 树链剖分的应用方法 以下是树链剖分的基本应用步骤: ```python # 树链剖分的实现示例(Python) from collections import defaultdict, deque class TreeChainDecomposition: def __init__(self, n): self.n = n self.adj = defaultdict(list) self.parent = [0] * (n + 1) self.depth = [0] * (n + 1) self.size = [0] * (n + 1) self.heavy = [0] * (n + 1) self.top = [0] * (n + 1) self.pos = [0] * (n + 1) self.rpos = [0] * (n + 1) self.cnt = 0 def add_edge(self, u, v): self.adj[u].append(v) self.adj[v].append(u) def dfs1(self, u, p): self.parent[u] = p self.size[u] = 1 max_subtree = -1 for v in self.adj[u]: if v != p: self.depth[v] = self.depth[u] + 1 self.dfs1(v, u) self.size[u] += self.size[v] if self.size[v] > max_subtree: max_subtree = self.size[v] self.heavy[u] = v def dfs2(self, u, t): self.top[u] = t self.pos[u] = self.cnt self.rpos[self.cnt] = u self.cnt += 1 if self.heavy[u] != 0: self.dfs2(self.heavy[u], t) for v in self.adj[u]: if v != self.parent[u] and v != self.heavy[u]: self.dfs2(v, v) # 示例:初始化并构建树 n = 5 tree = TreeChainDecomposition(n) edges = [(1, 2), (1, 3), (2, 4), (2, 5)] for u, v in edges: tree.add_edge(u, v) tree.dfs1(1, 0) tree.dfs2(1, 1) ``` 上述代码实现了树链剖分的基本框架,包括深度优先搜索(DFS)和重链划分。 #### 4. 实际应用案例 以 bzoj3252 为例,题目要求在树状结构中求解路径的最大价值和。这种问题可以通过树链剖分结合线段树或树状数组来解决。具体步骤如下: - 使用树链剖分将树划分为若干条链。 - 对每条链建立线段树或其他支持快速区间查询和修改的数据结构。 - 在查询或修改时,将路径拆分为若干条链,并分别在线段树上进行操作[^3]。 #### 5. 注意事项 - 树链剖分的时间复杂度通常为 \(O(n \log n)\),适合处理大规模数据。 - 在实际应用中,需要根据问题的具体需求选择合适的剖分方式(如重链剖分或长链剖分)。 - 结合其他数据结构(如线段树、树状数组)可以进一步提升效率。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值