[SP16549]QTREE6

luogu
vjudge

题意

给你一棵n个点的树，编号1~n。每个点可以是黑色，可以是白色。初始时所有点都是黑色。支持两种操作：
0 u：询问有多少个节点v满足路径u到v上所有节点（包括）都拥有相同的颜色
1 u：翻转u的颜色

sol

第一问其实就是问u所在的同色连通块的大小。
有一种很直接的想法就是，维护两种颜色的\(LCT\)，在每一种颜色的\(LCT\)中把同色连通块\(link\)起来。
这样一次操作的复杂度是与度数相关的，然后菊花树就被卡掉了吧。

把原树当做是一棵以1为根的有根树，我们考虑把一个点的颜色附到连接他的父亲的那条边上，这样每次修改操作就只涉及到一条边。

这样同色的点在这棵树上依旧是一个连通块。
但是一个连通块并不一定同色。
因为这个连通块的\(LCA\)不一定是同色呀。
所以特判一下就好了。
即如果是同色就直接输出\(LCA\)中存的值，否则输出\(LCA\)在splay中的右儿子存的值（因为\(LCA\)肯定是最浅的点也就是splay中中序遍历最靠前的点）。

code

#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
int gi()
{
    int x=0,w=1;char ch=getchar();
    while ((ch<'0'||ch>'9')&&ch!='-') ch=getchar();
    if (ch=='-') w=0,ch=getchar();
    while (ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return w?x:-x;
}
const int N = 1e5+5;
int n,m,col[N],fa[N];
vector<int>G[N];
struct LCT{
    int fa[N],ch[2][N],sum[N],sz[N];
    bool son(int x){return x==ch[1][fa[x]];}
    bool isroot(int x)
        {
            return x!=ch[0][fa[x]]&&x!=ch[1][fa[x]];
        }
    void pushup(int x)
        {
            sum[x]=sum[ch[0][x]]+sum[ch[1][x]]+sz[x]+1;
        }
    void rotate(int x)
        {
            int y=fa[x],z=fa[y],c=son(x);
            ch[c][y]=ch[c^1][x];if (ch[c][y]) fa[ch[c][y]]=y;
            fa[x]=z;if (!isroot(y)) ch[son(y)][z]=x;
            ch[c^1][x]=y;fa[y]=x;pushup(y);
        }
    void splay(int x)
        {
            for (int y=fa[x];!isroot(x);rotate(x),y=fa[x])
                if (!isroot(y)) son(x)^son(y)?rotate(x):rotate(y);
            pushup(x);
        }
    void access(int x)
        {
            for (int y=0;x;y=x,x=fa[x])
            {
                splay(x);sz[x]+=sum[ch[1][x]];
                ch[1][x]=y;sz[x]-=sum[ch[1][x]];
                pushup(x);
            }
        }
    int findroot(int x)
        {
            access(x);splay(x);
            while (ch[0][x]) x=ch[0][x];
            splay(x);return x;
        }
    void link(int x,int y)
        {
            if (!y) return;
            access(y);splay(y);splay(x);
            fa[x]=y;sz[y]+=sum[x];pushup(y);
        }
    void cut(int x,int y)
        {
            if (!y) return;
            access(x);splay(x);
            ch[0][x]=fa[ch[0][x]]=0;pushup(x);
        }
}T[2];
void dfs(int u,int f)
{
    for (int i=0,sz=G[u].size();i<sz;++i)
    {
        int v=G[u][i];if (v==f) continue;
        T[0].link(v,u);fa[v]=u;
        dfs(v,u);
    }
}
int main()
{
    n=gi();
    for (int i=1;i<n;++i)
    {
        int u=gi(),v=gi();
        G[u].push_back(v);G[v].push_back(u);
    }
    dfs(1,0);
    m=gi();
    while (m--)
    {
        int opt=gi(),u=gi();
        if (opt) T[col[u]].cut(u,fa[u]),col[u]^=1,T[col[u]].link(u,fa[u]);
        else{
            T[col[u]].access(u);int ff=T[col[u]].findroot(u);
            if (col[ff]==col[u]) printf("%d\n",T[col[u]].sum[ff]);
            else printf("%d\n",T[col[u]].sum[T[col[u]].ch[1][ff]]);
        }
    }
    return 0;
}

转载于:https://www.cnblogs.com/zhoushuyu/p/8747294.html