luogu 5354 [Ynoi2017]由乃的OJ LCT+位运算

如果做过起床困难综合征的话应该很快就能有思路，没做过那道题的话还真是挺费劲的.

我们不知道要带入的值是什么，但是我们可以知道假设带入值得当前位为 $1$ 时这一位在经过位运算后是否为 $1$.

至于这个怎么维护，我们开两个变量 $f0,f1$ 代表初始带入全 $0$，全 $1$ 时每一位得值.

然后在 $LCT$ 中维护从左向右，从右向左两个方向上得这个东西，注意一下 $pushup$ 函数得写法.

这段代码十分优美，利用了按位取反等骚操作：

struct node
{
    ll f0,f1;
    node operator+(const node &b) const
    {
        node a;
        a.f0=(~f0&b.f0)|(f0&b.f1);
        a.f1=(~f1&b.f0)|(f1&b.f1);
        return a;
    }
}f[N],L[N],R[N];

code:

#include <bits/stdc++.h>
#define N 100007
#define ll unsigned long long
#define setIO(s) freopen(s".in","r",stdin) ,freopen(s".out","w",stdout)
using namespace std;
int n,m,k,edges;
int hd[N],to[N<<1],nex[N<<1];
void addedge(int u,int v)
{
    nex[++edges]=hd[u],hd[u]=edges,to[edges]=v;
}
struct node
{
    ll f0,f1;
    node operator+(const node &b) const
    {
        node a;
        a.f0=(~f0&b.f0)|(f0&b.f1);
        a.f1=(~f1&b.f0)|(f1&b.f1);
        return a;
    }
}f[N],L[N],R[N];
struct Link_Cut_Tree
{
    #define lson p[x].ch[0]
    #define rson p[x].ch[1]
    int sta[N];
    struct Node
    {
        int ch[2],f,rev;
    }p[N];
    int get(int x)
    {
        return p[p[x].f].ch[1]==x;
    }
    int isrt(int x)
    {
        return !(p[p[x].f].ch[0]==x||p[p[x].f].ch[1]==x);
    }
    void pushup(int x)
    {
        L[x]=R[x]=f[x];
        if(lson) L[x]=L[lson]+L[x], R[x]=R[x]+R[lson];
        if(rson) L[x]=L[x]+L[rson], R[x]=R[rson]+R[x];
    }
    void rotate(int x)
    {
        int old=p[x].f,fold=p[old].f,which=get(x);
        if(!isrt(old)) p[fold].ch[p[fold].ch[1]==old]=x;
        p[old].ch[which]=p[x].ch[which^1],p[p[old].ch[which]].f=old;
        p[x].ch[which^1]=old,p[old].f=x,p[x].f=fold;
        pushup(old),pushup(x);
    }
    void mark(int x)
    {
        if(!x) return;
        swap(lson,rson), swap(L[x],R[x]),p[x].rev^=1;
    }
    void pushdown(int x)
    {
        if(p[x].rev)
        {
            p[x].rev=0;
            if(lson) mark(lson);
            if(rson) mark(rson);
        }
    }
    void splay(int x)
    {
        int u=x,v=0,fa;
        for(sta[++v]=u;!isrt(u);u=p[u].f) sta[++v]=p[u].f;
        for(;v;--v) pushdown(sta[v]);
        for(u=p[u].f;(fa=p[x].f)!=u;rotate(x))
            if(p[fa].f!=u)
                rotate(get(fa)==get(x)?fa:x);
    }
    void Access(int x)
    {
        for(int y=0;x;y=x,x=p[x].f)
        {
            splay(x);
            rson=y;
            pushup(x);
        }
    }
    void makeroot(int x)
    {
        Access(x),splay(x),mark(x);
    }
    void split(int x,int y)
    {
        makeroot(x), Access(y), splay(y);
    }
    void link(int x,int y)
    {
        makeroot(x), p[x].f=y;
    }
    void cut(int x,int y)
    {
        makeroot(x),Access(y),splay(y);
        p[y].ch[0]=p[x].f=0;
        pushup(y);
    }
    #undef lson
    #undef rson
}lct;
void solve(int x,int y,ll z)
{
    lct.split(x,y);
    int i;
    ll re=0;
    for(i=k-1;i>=0;--i)
    {
        if(L[y].f0&(1ll<<i)) re+=(1ll<<i);
        else if((L[y].f1&(1ll<<i)) && (1ll<<i)<=z) re+=(1ll<<i), z-=(1ll<<i);
    }
    printf("%llu\n",re);
}
void dfs(int u,int ff)
{
    lct.p[u].f=ff;
    for(int i=hd[u];i;i=nex[i])
        if(to[i]!=ff) dfs(to[i],u);
}
int main()
{
    int i,j;
    // setIO("input");
    scanf("%d%d%d",&n,&m,&k);
    for(i=1;i<=n;++i)
    {
        int op;
        ll y;
        scanf("%d%llu",&op,&y);
        if(op==1) f[i]=(node){0ll,y};
        if(op==2) f[i]=(node){y,~0ll};
        if(op==3) f[i]=(node){y,~y};
        lct.pushup(i);
    }
    for(i=1;i<n;++i)
    {
        int u,v;
        scanf("%d%d",&u,&v),addedge(u,v),addedge(v,u);
    }
    dfs(1,0);
    for(i=1;i<=m;++i)
    {
        int op;
        scanf("%d",&op);
        if(op==1)
        {
            int x,y;
            ll z;
            scanf("%d%d%llu",&x,&y,&z);
            solve(x,y,z);
        }
        else
        {
            int x,y;
            ll z;
            scanf("%d%d%llu",&x,&y,&z);
            lct.Access(x);
            lct.splay(x);
            if(y==1) f[x]=(node){0ll,z};
            if(y==2) f[x]=(node){z,~0ll};
            if(y==3) f[x]=(node){z,~z};
            lct.pushup(x);
        }
    }
    return 0;
}