bzoj 3637: Query on a tree VI 树链剖分 && AC600

3637: Query on a tree VI

Time Limit: 8 Sec  Memory Limit: 1024 MB
Submit: 206  Solved: 38
[Submit][Status][Discuss]

Description

You are given a tree (an acyclic undirected connected graph) with n nodes. The tree nodes are numbered from 1 to n.

Each node has a color, white or black. All the nodes are black initially.

We will ask you to perfrom some instructions of the following form:

• 0 u : ask for how many nodes are connected to u, two nodes are connected iff all the node on the path from u to v (inclusive u and v) have a same color.
• 1 u : toggle the color of u(that is, from black to white, or from white to black).

 

Input

The first line contains a number n denoted how many nodes in the tree(1 ≤ n ≤ 10⁵). The next n - 1 lines, each line has two numbers (u,  v) describe a edge of the tree(1 ≤ u,  v ≤ n). The next line contains a number m denoted how many operations we are going to process(1 ≤ m ≤ 10⁵). The next m lines, each line describe a operation (t,  u) as we mentioned above(0 ≤ t ≤ 1, 1 ≤ u ≤ n).

Output

 

For each query operation, output the corresponding result.

Sample Input

5
1 2
1 3
1 4
1 5
3
0 1
1 1
0 1

Sample Output

5
1

HINT

Source

　　这道题常数卡的有点紧，我树链剖分用一棵线段树存就TLE了，每个链分别建线段树才行。

　　考虑将每一个同色块的答案保存在这一块深度最浅的那一个点（这是一个很好的思路），我们考虑如何维护即可，对于每一个点，我们维护f[now][0/1]表示当前点如果取白色/黑色，所在的子树中与这个点同色的联通块大小。

　　每次颜色修改只会影响到当前点到根节点路径上的一段。而且还是路径加减一个数，这可以用链剖维护。

　　询问时只用跳到当前联通块最上方的点，然后输出该点所存的f值即可。

　　

　　AC600了，lalala～～

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
#define MAXN 101000
#define MAXV MAXN*2
#define MAXE MAXV*2
#define MAXT MAXN*4
#define lch sgt[now].lc
#define rch sgt[now].rc
#define smid ((l+r)>>1)
#define INF 0x3f3f3f3f
struct Edge
{
        int np;
        Edge *next;
}E[MAXE],*V[MAXV];
int tope=-;
void addedge(int x,int y)
{
        E[++tope].np=y;
        E[tope].next=V[x];
        V[x]=&E[tope];
}

int q[MAXN];
int pnt[MAXN];
int siz[MAXN];
int son[MAXN],top[MAXN],pos[MAXN],apos[MAXN],dfstime;
void bfs(int now)
{
        int head=-,tail=;
        Edge *ne;
        q[]=now;
        pnt[now]=;
        while (head<tail)
        {
                now=q[++head];
                for (ne=V[now];ne;ne=ne->next)
                {
                        if (ne->np==pnt[now])continue;
                        pnt[ne->np]=now;
                        q[++tail]=ne->np;
                }
        }
        for (int i=tail;i>=;i--)
        {
                now=q[i];
                siz[now]=;
                int mxsiz=;
                for (ne=V[now];ne;ne=ne->next)
                {
                        if (ne->np==pnt[now])continue;
                        siz[now]+=siz[ne->np];
                        if (siz[ne->np]>mxsiz)
                        {
                                mxsiz=now;
                                son[now]=ne->np;
                        }
                }
        }
}
int stack[MAXN],tops=-;
void dfs(int now)
{
        Edge *ne;
        stack[++tops]=now;
        top[now]=now;
        while (~tops)
        {
                now=stack[tops--];
                pos[now]=++dfstime;
                apos[dfstime]=now;
                for (ne=V[now];ne;ne=ne->next)
                {
                        if (ne->np==pnt[now] || ne->np==son[now])continue;
                        stack[++tops]=ne->np;
                        top[ne->np]=ne->np;
                }
                if (son[now])
                {
                        stack[++tops]=son[now];
                        top[son[now]]=top[now];
                }
        }
}
int col[MAXN];
int ptra[MAXN];
struct sgt_node
{
        int lc,rc;
        int sum[];
        int pls[];
        int val[];
}sgt[MAXT];
int topt=;
void make_plus(int now,int c,int d)
{
        sgt[now].val[c]+=d;
        sgt[now].pls[c]+=d;
}
void down(int now)
{
        if (sgt[now].pls[])
        {
                make_plus(lch,,sgt[now].pls[]);
                make_plus(rch,,sgt[now].pls[]);
                sgt[now].pls[]=;
        }
        if (sgt[now].pls[])
        {
                make_plus(lch,,sgt[now].pls[]);
                make_plus(rch,,sgt[now].pls[]);
                sgt[now].pls[]=;
        }
}
int Build_sgt(int l,int r)
{
        int now=++topt;
        sgt[now].val[]=sgt[now].val[]=sgt[now].pls[]=sgt[now].pls[]=;
        sgt[now].sum[]=;
        sgt[now].sum[]=;
        if (l==r)
        {
                ptra[l]=now;
                sgt[now].val[]=siz[apos[l]];
                sgt[now].val[]=;
                return now;
        }
        lch=Build_sgt(l,smid);
        rch=Build_sgt(smid+,r);
        return now;
}
pair<int,int> Query_sgt(int now,int l,int r,int pos)
{
        if (l==r)
                return make_pair(sgt[now].val[],sgt[now].val[]);
        down(now);
        if (pos<=smid)
                return Query_sgt(lch,l,smid,pos);
        else
                return Query_sgt(rch,smid+,r,pos);
}
void Modify_sgt(int now,int l,int r,int x,int y,int c,int d)
{
        if (l==x && r==y)
        {
                make_plus(now,c,d);
                return ;
        }
        down(now);
        if (y<=smid)
                return Modify_sgt(lch,l,smid,x,y,c,d);
        else if (smid<x)
                return Modify_sgt(rch,smid+,r,x,y,c,d);
        else
        {
                Modify_sgt(rch,smid+,r,smid+,y,c,d);
                Modify_sgt(lch,l,smid,x,smid,c,d);
        }
}
void Modify_sgt2(int now,int l,int r,int pos)
{
        if (l==r)
                return swap(sgt[now].sum[],sgt[now].sum[]);
        down(now);
        if (pos<=smid)
                Modify_sgt2(lch,l,smid,pos);
        else
                Modify_sgt2(rch,smid+,r,pos);
        sgt[now].sum[]=sgt[lch].sum[]+sgt[rch].sum[];
        sgt[now].sum[]=sgt[lch].sum[]+sgt[rch].sum[];
}
int Scan_sgt(int now,int l,int r,int x,int y,int c)
{
        if (l==x && r==y)
        {
                if (sgt[now].sum[c]==(r-l+))
                {
                        return l;
                }else if (sgt[now].sum[c]==)
                {
                        return -;
                }else
                {
                        down(now);
                        int ret=Scan_sgt(rch,smid+,r,smid+,y,c);
                        if (ret==smid+)
                        {
                                ret=Scan_sgt(lch,l,smid,x,smid,c);
                                if (ret==-)return smid+;
                                else return ret;
                        }else return ret;
                }
        }
        down(now);
        if (y<=smid)
                return Scan_sgt(lch,l,smid,x,y,c);
        else if (smid<x)
                return Scan_sgt(rch,smid+,r,x,y,c);
        else
        {
                int ret=Scan_sgt(rch,smid+,r,smid+,y,c);
                if (ret==smid+)
                {
                        ret=Scan_sgt(lch,l,smid,x,smid,c);
                        if (ret==-)return smid+;
                        else return ret;
                }else return ret;
        }
}
int spos[MAXN],tpos[MAXN];
int troot[MAXN];
int Swim_up(int x)
{
        int rpos=pos[x];
        int c=col[x];
        while (x)
        {
                int y=Scan_sgt(troot[top[x]],spos[top[x]],tpos[top[x]],pos[top[x]],pos[x],c);
                if (y==-)break;
                else if (y!=pos[top[x]])
                {
                        rpos=y;break;
                }else
                {
                        rpos=y;
                        x=pnt[top[x]];
                }
        }
        return apos[rpos];
}
int main()
{
        freopen("input.txt","r",stdin);
        freopen("output.txt","w",stdout);
        int n,m;
        int x,y,z;
        scanf("%d",&n);
        for (int i=;i<n;i++)
        {
                scanf("%d%d",&x,&y);
                addedge(x,y);
                addedge(y,x);
        }
        bfs();
        dfs();
        for (int i=;i<=n;i++)
                spos[i]=INF,tpos[i]=-INF;
        for (int i=;i<=n;i++)
                spos[top[i]]=min(spos[top[i]],pos[i]);
        for (int i=;i<=n;i++)
                tpos[top[i]]=max(tpos[top[i]],pos[i]);
        for (int i=;i<=n;i++)
                if (top[i]==i)
                        troot[i]=Build_sgt(spos[i],tpos[i]);
        scanf("%d",&m);
        int opt;
        for (int i=;i<=n;i++)col[i]=;
        for (int i=;i<m;i++)
        {
                scanf("%d%d",&opt,&x);
                if (opt==)
                {
                        int rpt=Swim_up(x);
                        pair<int,int> res=Query_sgt(troot[top[rpt]],spos[top[rpt]],tpos[top[rpt]],pos[rpt]);
                        if (col[x]==)
                                printf("%d\n",res.first);
                        else
                                printf("%d\n",res.second);
                }else
                {
                        pair<int,int> res=Query_sgt(troot[top[x]],spos[top[x]],tpos[top[x]],pos[x]);
                        int p=pnt[x];
                        int c=col[p];
                        int d,d2;
                        if (col[p]== && col[x]==)d=-res.second,d2=res.first;
                        else if (col[p]== && col[x]==)d=res.second,d2=-res.first;
                        else if (col[p]== && col[x]==)d=res.first,d2=-res.second;
                        else d=-res.first,d2=res.second;
                        if (p)
                        {
                                sgt[ptra[pos[p]]].val[c^]+=d2;
                                int a=Swim_up(p);
                                a=pnt[a];
                                if (!a)a=;
                                while (true)
                                {
                                        if (top[p]==top[a])
                                        {
                                                Modify_sgt(troot[top[a]],spos[top[a]],tpos[top[a]],pos[a],pos[p],c,d);
                                                break;
                                        }
                                        Modify_sgt(troot[top[p]],spos[top[p]],tpos[top[p]],pos[top[p]],pos[p],c,d);
                                        p=pnt[top[p]];
                                }
                        }
                        Modify_sgt2(troot[top[x]],spos[top[x]],tpos[top[x]],pos[x]);
                        col[x]^=;
                }
        }
}