[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=;

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

 int n, m;
 int f[sizeOfPoint], d[sizeOfPoint], s[sizeOfPoint];
 int p[][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<<], * port_node=memory_node;
 inline node * newnode(int, int);
 node * build(int, int);
 void update(node * , int);
 int query(node * , int, int);

 int sum[][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<<], * 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=;i<n;i++)
     {
         int u=getint(), v=getint();
         link(u, v);
     }

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

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

         if (o==)
         {
             int f=query(u);
             putint(+query(sum[c[f]], idx[f]));
         }
         else if (u==) c[u]^=;
         else
         {
             int s=query(sum[c[u]], idx[u])+;
             c[u]^=;
             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])+;
                 if (a==) update(c[u], f[u], a, s);
                 else update(c[u], f[u], f[a], s);
             }
             else
             {
                 int a=query(f[u]);
                 if (a==) update(!c[u], f[u], a, -s);
                 else update(!c[u], f[u], f[a], -s);
                 s=query(sum[c[u]], idx[u])+;
                 update(sum[c[u]], idx[f[u]], idx[f[u]], s);
             }
         }
     }

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

 inline void node::maintain()
 {
     lc=l->lc; rc=r->rc;
     len=r->len;
     if (len==r->rr-r->ll+ && 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=;
     else
     {
         int m=(ll+rr)>>;
         t->l=build(ll, m);
         t->r=build(m+, 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)>>;
         if (k<=m) update(t->l, k);
         else update(t->r, k);
         t->maintain();
     }
 }
 int query(node * t, int ql, int qr)
 {
     int ret=;
     if (t->ll==ql && t->rr==qr) ret=t->len;
     else
     {
         int m=(t->ll+t->rr)>>;
         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+, 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=;
     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?:-__builtin_clz(u);
 }
 void dfs_tree(int u)
 {
     s[u]=;
     for (int i=;i<=lg(d[u]);i++) p[i][u]=p[i-][p[i-][u]];
     for (edge * i=e[u];i;i=i->next) if (d[i->point]==-)
     {
         f[i->point]=u; d[i->point]=d[u]+;
         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=;i>=;i--)
         if ((k>>i)&)
             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]+)
         {
             if (top[u]==) return ;
             if (c[top[u]]==c[f[top[u]]]) u=f[top[u]];
             else return top[u];
         }
         else
             return anc(u, l-);
     }
 }

解锁新成就：rank last