BZOJ3729Gty的游戏——非旋转treap+阶梯博弈+巴什博弈-布布扣-bubuko.com

题目描述

某一天gty在与他的妹子玩游戏。
妹子提出一个游戏，给定一棵有根树，每个节点有一些石子，每次可以将不多于L的石子移动到父节点，询问
将某个节点的子树中的石子移动到这个节点先手是否有必胜策略。
gty很快计算出了策略。
但gty的妹子十分机智，她决定修改某个节点的石子或加入某个新节点。
gty不忍心打击妹子，所以他将这个问题交给了你。
另外由于gty十分绅士，所以他将先手让给了妹子。

输入

第一行两个数字，n和L,n<=5*10^4,L<=10^9
第二行n个数字，表示每个节点初始石子数。
接下来n-1行，每行两个整数u和v，表示有一条从u到v的边。
接下来一行一个数m，表示m组操作。
接下来m行，每行第一个数字表示操作类型
若为1，后跟一个数字v，表示询问在v的子树中做游戏先手是否必胜。
若为2，后跟两个数字x，y表示将节点x的石子数修改为y。
若为3，后跟三个数字u,v,x，表示为u节点添加一个儿子v，初始石子数为x。
在任意时刻，节点数不超过5*10^4。

输出

对于每个询问，若先手必胜，输出"MeiZ",否则输出"GTY"。
另，数据进行了强制在线处理，对于m组操作，除了类型名以外，都需要异或之前回答为"MeiZ"的个数。

样例输入

2 1000
0 0
1 2
1
1 1

样例输出

GTY

对于每个询问就是在子树中做阶梯巴什博弈。

判断谁能赢只要求出与子树根节点深度奇偶性不同的所有子树内点的SG值的异或和就行了。

巴什博弈的SG值就是石子数%(L+1)。

如果没有加点操作直接在线段树上维护dfs序就行了，但有了加点操作就要动态维护dfs序。

每次加一个点直接将这个点插入到它父亲dfs序位置的后面即可，同时记录每个点对应的平衡树上点的编号。

如果是用splay写那么直接可以通过父节点在splay上点的编号进行操作。

但用非旋转treap的话你发现因为dfs是动态的，所以无法知道加入点父节点在treap中对应编号点具体的位置，也就无法从根往下找到这个点。

这时就要记录每个点在treap上父节点是谁然后从操作点自下而上反向分裂(详细做法参见平衡树讲解)。

同样因为dfs序动态的，我们也不知道一个点的子树在dfs上的区间到哪截止，这里有一个判断方法：

从子树根节点在dfs序上位置往右第一个深度小于等于它的点之前都是它子树中的点。

因此在treap上还要维护区间在原树上深度最小值，加上之前维护的奇数偶数层SG值异或和共三个区间信息。

注意因为treap上要维护父节点是谁，因此在split和merge时都要更新父亲数组。

#include<set>
#include<map>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<bitset>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int n,L,m;
int ls[100010];
int rs[100010];
int sum[100010];
int num[100010];
int mn[100010];
int val[100010];
int v[100010];
int r[100010];
int d[100010];
int dep[100010];
int s[100010];
int f[100010];
int head[100010];
int to[200010];
int next[200010];
int tot;
int cnt;
int opt;
int ans;
int x,y,z;
int a,b,c;
int root;
void add(int x,int y)
{
    tot++;
    next[tot]=head[x];
    head[x]=tot;
    to[tot]=y;
}
int build(int val,int dep)
{
    int rt=++cnt;
    v[rt]=val;
    r[rt]=rand();
    ls[rt]=rs[rt]=0;
    d[rt]=dep;
    mn[rt]=d[rt];
    if(d[rt]%2==0)
    {
        num[rt]=v[rt];
    }
    sum[rt]=v[rt];
    return rt;
}
void pushup(int rt)
{
    sum[rt]=sum[ls[rt]]^sum[rs[rt]]^v[rt];
    num[rt]=num[ls[rt]]^num[rs[rt]];
    if(d[rt]%2==0)
    {
        num[rt]^=v[rt];
    }
    mn[rt]=d[rt];
    if(ls[rt])
    {
        mn[rt]=min(mn[rt],mn[ls[rt]]);
    }
    if(rs[rt])
    {
        mn[rt]=min(mn[rt],mn[rs[rt]]);
    }
}
int merge(int x,int y)
{
    if(!x||!y)
    {
        return x+y;
    }
    if(r[x]<r[y])
    {
        rs[x]=merge(rs[x],y);
        f[rs[x]]=x;
        if(!rs[x])
        {
            f[0]=0;
        }
        pushup(x);
        return x;
    }
    else
    {
        ls[y]=merge(x,ls[y]);
        f[ls[y]]=y;
        if(!ls[y])
        {
            f[0]=0;
        }
        pushup(y);
        return y;
    }
}
void dfs(int x,int fa)
{
    dep[x]=dep[fa]+1;
    s[x]=build(val[x],dep[x]);
    root=merge(root,s[x]);
    for(int i=head[x];i;i=next[i])
    {
        if(to[i]!=fa)
        {
            dfs(to[i],x);
        }
    }
}
void split1(int rt,int &a,int &b)
{
    int x=ls[rt];
    int y=rs[rt];
    ls[rt]=rs[rt]=0;
    num[rt]=sum[rt]=0;
    sum[rt]=v[rt];
    mn[rt]=d[rt];
    if(d[rt]%2==0)
    {
        num[rt]=v[rt];
    }
    while(f[rt])
    {
        if(ls[f[rt]]==rt) 
        {
            ls[f[rt]]=y;
            f[y]=f[rt];
            y=f[rt];
            pushup(f[rt]);
        }
        else
        {
            rs[f[rt]]=x;
            f[x]=f[rt];
            x=f[rt];
            pushup(f[rt]);
        }
        rt=f[rt];
    }
    a=x;
    b=y;
}
void split2(int rt,int &x,int &y,int k)
{
    if(!rt)
    {
        x=y=0;
        return ;
    }
    if(mn[ls[rt]]<=k)
    {
        y=rt;
        split2(ls[rt],x,ls[y],k);
        f[ls[y]]=y;
        pushup(rt);
    }
    else if(d[rt]<=k)
    {
        x=ls[rt];
        y=rt;
        ls[rt]=0;
        pushup(rt);
        return ;
    }
    else
    {
        x=rt;
        split2(rs[rt],rs[x],y,k);
        f[rs[x]]=x;
        pushup(rt);
    }
}
int main()
{
    scanf("%d%d",&n,&L);
    L++;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&z);
        val[i]=z%L;
    }
    for(int i=1;i<n;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y);
        add(y,x);
    }
    dfs(1,0);
    mn[0]=n+1;
    scanf("%d",&m);
    while(m--)
    {
        a=b=c=0;
        scanf("%d",&opt);
        if(opt==1)
        {
            scanf("%d",&x);
            x^=ans;
            split1(s[x],a,b);
            split2(b,b,c,dep[x]);
            b=merge(s[x],b);
            if(dep[x]&1)
            {
                if(num[b]==0)
                {
                    printf("GTY\n");
                }
                else
                {
                    ans++;
                    printf("MeiZ\n");
                }
            }
            else
            {
                if((num[b]^sum[b])==0)
                {
                    printf("GTY\n");
                }
                else
                {
                    ans++;
                    printf("MeiZ\n");
                }
            }
            root=merge(merge(a,b),c);
        }
        else if(opt==2)
        {
            scanf("%d%d",&x,&z);
            x^=ans;
            z^=ans;
            split1(s[x],a,b);
            v[s[x]]=z%L;
            sum[s[x]]=z%L;
            num[s[x]]=0;
            if(d[s[x]]%2==0)
            {
                num[s[x]]=z%L;
            }
            b=merge(s[x],b);
            root=merge(a,b);
        }
        else
        {
            scanf("%d%d%d",&x,&y,&z);
            x^=ans;
            y^=ans;
            z^=ans;
            dep[y]=dep[x]+1;
            s[y]=build(z%L,dep[y]);
            split1(s[x],a,b);
            a=merge(a,s[x]);
            a=merge(a,s[y]);
            root=merge(a,b);
        }
    }
}

BZOJ3729Gty的游戏——非旋转treap+阶梯博弈+巴什博弈

原文：https://www.cnblogs.com/Khada-Jhin/p/9971174.html