BZOJ 4202: 石子游戏 SG定理+LCT

4202: 石子游戏

Time Limit: 10 Sec   Memory Limit: 128 MB
Submit: 37   Solved: 15
[ Submit][ Status][ Discuss]

Description

石子游戏是大家都很喜欢玩的一类游戏，这类游戏通常与石子的移动和取

舍有关，往往可以让人在游戏中获得不少的乐趣。

有一类树上石子游戏的规则是这样的：在一棵有根树上，每个节点都有着

一定数目的石子，两个玩家轮流进行游戏。每次，每个玩家可以把不超过 m 个

的石子移动到它的父亲上。显然，根节点没有父亲，故每个石子一旦移动到根

节点便无法再次移动。问题是以某个节点为根的子树进行这样的游戏，是否存

在先手必胜策略。

为了增加这个游戏的难度，我们对这个游戏进行一些小小的修改。现在，

我们的这棵树可能会长出新的节点。同时，每个节点上的石子数目可能会变化。

请问，以某个节点为根的子树进行这样的石子游戏，是否存在先手必胜策略。

Input

第一行包含两个数字 n 和 m，表示初始时有 n 个节点，

每次移动不能超过 m 个。

第二行 n 个正整数 a1,a2...an，表示初始时候的石子数量，其中 1 号节

点为根节点。

接下来 n   1 行，每行两个整数 u 和 v，表示有一条从 u 到 v 的边。

接下来一行一个数 t,表示操作的数目。

接下来 t 行，每行代表一个操作，每行的第一个数字代表操作类型，其中：

若为 1，后跟一个数字 v，表示询问在 v 的子树中做游戏先手是否必胜。

若为 2，后跟两个数字 x， y 表示将节点 x 的石子数修改为 y。

若为 3，后跟三个数字 u， v， x，表示为 u 节点添加一个儿子 v，初始石

子数为 x。

Output

对于每一个询问，若先手必胜输出“Yes”，否则输出“No”。

注，数据进行了强制在线处理，对于每一个操作，除类型名外，都需要异

或之前回答为“Yes“的数目。

Sample Input

2 1000
0 0
1 2
1
1 1

Sample Output

No

HINT

对于100%的数据， n,t <= 50000。

同时，保证任何时刻树中节点数目和编号都不会超过 100000。

其余数据的范围皆在int范围内。

Source

[ Submit][ Status][ Discuss]

Sol：

树上博弈，先考虑SG那套理论

取石子向上移动？阶梯NIM -- 只考虑奇数堆做NIM即可，对手奇->偶相当于取走石子，设法将异或和再次变成0，对手偶->奇相当于添加石子，再把等量石子奇->偶即可

树上阶梯NIM？ 将根节点深度看做0，只考虑奇深度即可

移动不超过m个？ Bash博弈，SG[x] = Stone[x] mod (m+1) 

必胜条件？ SG定理，子游戏SG函数值异或和为0 -> 先手必败 否则先手必胜。

好了，现在考虑如何实现修改。

离线的话，单点修改，子树查询，很容易先到dfs序+树状数组/线段树什么的，添加儿子可以先添加好后处理dfs序再做。。。

在线的话就行不通了，换一个角度考虑子树查询：一个点修改影响的点一定在她到根的路径上 -> 转化为链上修改

加儿子？Link_Cut_Tree来一发

询问奇数深度的点要查询子树内偶数深度点的异或和，相反同理。

开两棵LCT，一棵仅接受奇数深度点的修改，一棵仅接受偶数，同时维护树的形态。

似乎不是很机智的做法，不过我太菜了只能想到这种暴力的做法QAQ

Code：

#include<bits/stdc++.h>
#define debug(x) cout<<#x<<"="<<x<<endl
using namespace std;
const int maxn = 100009;
int tot;
int n,m,q;
struct LCT
{
    int fa[maxn],son[maxn][2],val[maxn],tag[maxn];
    stack<int>S;
    bool rev[maxn];
    inline bool is_root(int x)
    {
        if(x==0) return 1;
        return (son[fa[x]][0]!=x)&&(son[fa[x]][1]!=x);
    }
    void down(int x)
    {
        if(tag[x])
        {
            val[son[x][0]]^=tag[x];
            tag[son[x][0]]^=tag[x];
            val[son[x][1]]^=tag[x];
            tag[son[x][1]]^=tag[x];
            tag[x]=0;
        }
        if(rev[x])
        {
            swap(son[x][0],son[x][1]);
            rev[son[x][0]]^=1;
            rev[son[x][1]]^=1;
            rev[x]=0;
        }
    }
    inline void rotate(int x)
    {
        int y=fa[x],z=fa[y],l,r;
        if(son[y][0]==x) l=0;else l=1;r=l^1;
        if(!is_root(y)) if(son[z][0]==y) son[z][0]=x;
                else son[z][1]=x;
        fa[x]=z;fa[y]=x;fa[son[x][r]]=y;
        son[y][l]=son[x][r];son[x][r]=y;
    }
    void splay(int x)
    {
        int y=x,z;
        while(!is_root(y)) S.push(y),y=fa[y];S.push(y);
        while(!S.empty()) down(S.top()),S.pop();
        while(!is_root(x))
        {
            y=fa[x];z=fa[y];
            if(!is_root(y)) if((son[y][0]==x)^(son[z][0]==y)) rotate(x);
                    else rotate(y);
            rotate(x);
        }
    }
    void access(int x)
    {
        int t=0;
        while(x)
        {
            splay(x);
            son[x][1]=t;
            t=x;x=fa[x];
        }
    }
    void make_root(int x)
    {
        access(x);splay(x);rev[x]^=1;
    }
    void link(int x,int y)
    {
        make_root(x);fa[x]=y;
    }
    void change(int x,int y)
    {
        make_root(1);access(x);
        splay(x);tag[x]^=y;val[x]^=y;
    }
    int query(int x)
    {
        make_root(1);access(x);splay(x);
        return val[x];
    }
}eve,odd;
int first[maxn];
struct edg
{
    int next;
    int to;
}e[maxn<<1];
int e_sum;
int a[maxn],id[maxn*10],dep[maxn];
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline void add_edg(int x,int y)
{
    e_sum++;
    e[e_sum].next=first[x];
    first[x]=e_sum;
    e[e_sum].to=y;
}
void dfs(int x,int fa)
{
    dep[x]=dep[fa]+1;
    for(int i=first[x];i;i=e[i].next)
    {
        int w=e[i].to;;
        if(w==fa) continue;
        dfs(w,x);
    }
}
int main()
{
    n=read();m=read();tot=n;
    for(int i=1;i<=n;i++) a[i]=read()%(m+1),id[i]=i;
    for(int i=1;i<n;i++)
    {
        int x=read(),y=read();
        add_edg(x,y);add_edg(y,x);
        eve.link(x,y);odd.link(x,y);
    }
    dfs(1,0);
    for(int i=1;i<=n;i++)
    {
        if(dep[i]&1) odd.change(i,a[i]);
        else eve.change(i,a[i]);
    }
    q=read();
    int cnt=0;
    while(q--)
    {
        int opt=read();
        if(opt==1)
        {
            int x=read()^cnt,sg;x=id[x];
            if(dep[x]&1) sg=eve.query(x);
            else sg=odd.query(x);
            if(sg) puts("Yes"),cnt++;
            else puts("No");
        }
        if(opt==2)
        {
            int x=read()^cnt,y=(read()^cnt)%(m+1);x=id[x];
            if(dep[x]&1) odd.change(x,a[x]),odd.change(x,y);
            else eve.change(x,a[x]),eve.change(x,y);
            a[x]=y;
        }
        if(opt==3)
        {
            int x=read()^cnt,y=read()^cnt,z=(read()^cnt)%(m+1);
            x=id[x];id[y]=++tot;y=id[y];dep[y]=dep[x]+1;a[y]=z;
            eve.link(x,y);odd.link(x,y);
            if(dep[y]&1) odd.change(y,z);
            else eve.change(y,z);
        }
    }
    return 0;
}