[BZOJ 3637]Query on a tree VI

偶然看见了这题，觉得自己 QTREE、COT 什么的都没有刷过的真是弱爆了……

一道思路很巧妙的题，终于是在约大爷的耐心教导下会了，真是太感谢约大爷了。

这题显然是树链剖分，但是链上维护的东西很恶心。其核心思想是找到一个相连的最浅同色节点，那么我只要维护每个点的子树中与他相连的点的数量即可

用 f[c][u] 表示在 u 的子树中与 u 相连 (假设 u 无色) 且颜色为 c 的点数

查询直接算出与 u 相连的最浅同色节点 a，ans=f[c[u]][a]

考虑修改，我们发现每次 u 被反转，影响到的点是 father[u] 一直往上，直到根或一个异色点（PS. 最浅异色 a 的 f[ ][a] 也会被改），而且他们的 f[][] 都是加一个数或减一个数

（PS2. father[u] 的 f[][] 会被改两次，因为 u 的颜色变了，导致 f[0][father[u]]、f[1][father[u]] 都在变）

区间修改，单点查询，于是用树状树组搞搞救过了

至于找到一个相连的最浅同色节点，可用线段树——比如：三叉神经树的做法

也可以在每条链上暴力挂 3 个 map 神马的……

反正是好 YY de 啦～

#include <cstdio>
#include <cstring>
const int sizeOfPoint=100001;

inline int getint();
inline void putint(int);

int n, m;
int f[sizeOfPoint], d[sizeOfPoint], s[sizeOfPoint];
int p[20][sizeOfPoint];
int num, idx[sizeOfPoint], son[sizeOfPoint], top[sizeOfPoint];
bool c[sizeOfPoint];

struct node
{
    int ll, rr;
    bool lc, rc;
    int len;
    node * l, * r;
    inline void maintain();
};
node * t;
node memory_node[sizeOfPoint<<2], * port_node=memory_node;
inline node * newnode(int, int);
node * build(int, int);
void update(node * , int);
int query(node * , int, int);

int sum[2][sizeOfPoint];
inline int lowbit(int);
inline void update(int * , int, int, int);
inline int query(int * , int);

struct edge {int point; edge * next;};
edge memory_edge[sizeOfPoint<<1], * port_edge=memory_edge;
edge * e[sizeOfPoint];
inline edge * newedge(int, edge * );
inline void link(int, int);
inline int lg(int);
void dfs_tree(int);
void dfs_chain(int, int);
inline int anc(int, int);
inline void update(bool, int, int, int);
inline int query(int);

int main()
{
    n=getint();
    for (int i=1;i<n;i++)
    {
        int u=getint(), v=getint();
        link(u, v);
    }

    memset(d, 0xFF, sizeof(d)); d[1]=0;
    dfs_tree(1);
    dfs_chain(1, 1);
    t=build(1, n);
    for (int i=1;i<=n;i++) update(sum[0], idx[i], idx[i], s[i]-1);

    m=getint();
    for (int i=1;i<=m;i++)
    {
        int o=getint(), u=getint();

        if (o==0)
        {
            int f=query(u);
            putint(1+query(sum[c[f]], idx[f]));
        }
        else if (u==1) c[u]^=1;
        else
        {
            int s=query(sum[c[u]], idx[u])+1;
            c[u]^=1;
            update(t, idx[u]);

            if (c[u]==c[f[u]])
            {
                update(sum[!c[u]], idx[f[u]], idx[f[u]], -s);
                int a=query(f[u]);
                s=query(sum[c[u]], idx[u])+1;
                if (a==1) update(c[u], f[u], a, s);
                else update(c[u], f[u], f[a], s);
            }
            else
            {
                int a=query(f[u]);
                if (a==1) update(!c[u], f[u], a, -s);
                else update(!c[u], f[u], f[a], -s);
                s=query(sum[c[u]], idx[u])+1;
                update(sum[c[u]], idx[f[u]], idx[f[u]], s);
            }
        }
    }

    return 0;
}
inline int getint()
{
    register int num=0;
    register char ch;
    do ch=getchar(); while (ch<'0' || ch>'9');
    do num=num*10+ch-'0', ch=getchar(); while (ch>='0' && ch<='9');
    return num;
}
inline void putint(int num)
{
    char stack[11];
    register int top=0;
    if (num==0) stack[top=1]='0';
    for ( ;num;num/=10) stack[++top]=num%10+'0';
    for ( ;top;top--) putchar(stack[top]);
    putchar('
');
}

inline void node::maintain()
{
    lc=l->lc; rc=r->rc;
    len=r->len;
    if (len==r->rr-r->ll+1 && l->rc==r->lc) len+=l->len;
}
inline node * newnode(int ll, int rr)
{
    node * ret=port_node++;
    ret->ll=ll; ret->rr=rr;
    ret->l=ret->r=NULL;
    return ret;
}
node * build(int ll, int rr)
{
    node * t=newnode(ll, rr);
    if (ll==rr) t->lc=t->rc=c[ll], t->len=1;
    else
    {
        int m=(ll+rr)>>1;
        t->l=build(ll, m);
        t->r=build(m+1, rr);
        t->maintain();
    }
    return t;
}
void update(node * t, int k)
{
    if (t->ll==t->rr) t->lc=t->rc=c[t->ll];
    else
    {
        int m=(t->ll+t->rr)>>1;
        if (k<=m) update(t->l, k);
        else update(t->r, k);
        t->maintain();
    }
}
int query(node * t, int ql, int qr)
{
    int ret=0;
    if (t->ll==ql && t->rr==qr) ret=t->len;
    else
    {
        int m=(t->ll+t->rr)>>1;
        if (qr<=m) ret=query(t->l, ql, qr);
        else if (ql>m) ret=query(t->r, ql, qr);
        else
        {
            ret=query(t->r, m+1, qr);
            if (ret==qr-m && t->r->lc==t->l->rc) ret+=query(t->l, ql, m);
        }
    }
    return ret;
}

inline int lowbit(int x)
{
    return x & -x;
}
inline void update(int * c, int l, int r, int v)
{
    for (   ;l<=n;l+=lowbit(l)) c[l]+=v;
    for (r++;r<=n;r+=lowbit(r)) c[r]-=v;
}
inline int query(int * c, int i)
{
    int ret=0;
    for ( ;i;i-=lowbit(i)) ret+=c[i];
    return ret;
}

inline edge * newedge(int point, edge * next)
{
    edge * ret=port_edge++;
    ret->point=point; ret->next=next;
    return ret;
}
inline void link(int u, int v)
{
    e[u]=newedge(v, e[u]); e[v]=newedge(u, e[v]);
}
inline int lg(int u)
{
    return !u?0:31-__builtin_clz(u);
}
void dfs_tree(int u)
{
    s[u]=1;
    for (int i=1;i<=lg(d[u]);i++) p[i][u]=p[i-1][p[i-1][u]];
    for (edge * i=e[u];i;i=i->next) if (d[i->point]==-1)
    {        
        f[i->point]=u; d[i->point]=d[u]+1;
        dfs_tree(i->point);
        s[u]+=s[i->point];
        if (s[i->point]>s[son[u]])
            son[u]=i->point;
    }
}
void dfs_chain(int u, int top_u)
{
    idx[u]=++num; top[u]=u;
    if (son[u]) dfs_chain(son[u], top_u);
    for (edge * i=e[u];i;i=i->next) if (!idx[i->point])
        dfs_chain(i->point, i->point);
}
inline int anc(int u, int k)
{
    for (int i=19;i>=0;i--)
        if ((k>>i)&1)
            u=p[k][u];
    return u;
}
inline void update(bool c, int u, int v, int s)
{
    while (top[u]!=top[v])
    {
        update(sum[c], idx[top[u]], idx[u], s);
        u=f[top[u]];
    }
    update(sum[c], idx[v], idx[u], s);
}
inline int query(int u)
{
    for ( ; ; )
    {
        int l=query(t, idx[top[u]], idx[u]);

        if (l==d[top[u]]-d[u]+1)
        {
            if (top[u]==1) return 1;
            if (c[top[u]]==c[f[top[u]]]) u=f[top[u]];
            else return top[u];
        }
        else
            return anc(u, l-1);
    }
}