【JZOJ3973】【NOI2015模拟1.10】【NOI2013湖南省队集训】黑白树(wbtree)（并查集）

Problem

　　给定一棵树,边的颜色为黑或白,初始时全部为白色。维护两个操作:
1. 查询u到根路径上的第一条黑色边的标号。
2. 将u到v路径上的所有边的颜色设为黑色。

Hint

　　对于30%的数据:$n,m≤10^3$
　　对于100%的数据:$n,m≤10^6$

Solution

　　这种题让人一看就想到链剖，但是看看数据范围：$10^6$，便知道链剖那$O(n(log_2n)^2)$的超高复杂度肯定卡不过去。
　　于是想到$O(nlog_2n)$的LCT，但是LCT常数巨大，多数情况下比链剖还慢，所以更不可能。
　　然而我比赛时又想不到好的方法，只好规规矩矩地打了个链剖，又颇感某个地方可能打错了，所以估了0分，结果真的爆0；然而，zhj竟很快凭借一个暴力水过了。所以我不得不祝出题人身体健康。
　　虽然我至今仍未发现我的链剖哪里打错了，但这不是重点——反正链剖也会T。正解是并查集。
　　首先，我们可在读入的时候按照它的读入顺序建一棵只含黑边的树，这样即可求出每一条边被染黑的时间（设至始至终为白色的边变黑的时间为m+1）。我们可以暴力连边，毕竟一条边最多只会被染一次。
　　但是我们可不能傻乎乎地一条一条边往上跳。我一开始打了个倍增lca，但是T了。于是我发现我们可以用一种较为神奇的方法连边：如要将x到y的路径变黑，设deep[x]>=deep[y]，则将x跳到根，若此时deep[x]依然>=deep[y]且x≠y，则表明x不为它们的lca或它们lca的祖先，那么我们便可将此时的x向它在原图中的父亲节点连边。当然，为了压缩路径，我们在并查集中直接向该父亲的根连边。这样即可在$O(nα(n))$内的时间完成连边。
　　随后，我们将所有的边的信息（编号及变黑的时间）和所有询问放在一个数组里，以时间为关键字从大到小排序。这样，我们就顺序扫一遍，相当于按原时间倒过来做一遍。
　　此时，我们须建一棵只含白边的树。每扫到有一条边变黑时，由于我们是倒过来做的，所以其实相当于将染色撤销，即将此边变回白色，我们在并查集中就从它向它原图中的父亲节点的根连边；每扫到一个询问点u时，我们就直接跳到u的根，而此时的根连向其父亲节点的边则定为u到原根路径上的第一条黑色边，那么输出此边的编号。
　　最后，由于未知原因，我这个程序跑得贼慢，T了好几遍，所以一定要打输入输出优化。
　　时间复杂度：$O(nα(n))$。

Code

#include <cstdio>
#include <cctype>
#include <algorithm>
#include <cstring>
using namespace std;
#define N 1000010
#define M 2*N
#define fo(i,a,b) for(i=a;i<=b;i++)
#define fd(i,a,b) for(i=a;i>=b;i--)
int i,n,m,u,v,tot,tov[M],next[M],last[N],d[N],fat[N],deep[N],num[N],f,fa[N],side[N],qs,ws,x,t,ans[N];
bool p;
struct operation
{
    int x,u,v;
}a[N];
struct Q
{
    int x,t;
    bool p;
}q[M];
struct mes
{
    int x;
    bool p;
    mes(){}
    mes(int _x,bool _p){x=_x;p=_p;}
}D[M];
void read(int &x)
{
    char c=getchar(); x=0;
    for(;!isdigit(c);c=getchar());
    for(;isdigit(c);x=(x<<3)+(x<<1)+c-'0',c=getchar());
}
inline void insert(int x,int y)
{
    tov[++tot]=y;
    next[tot]=last[x];
    last[x]=tot;
}
void print(int x)
{
    if(x>9)print(x/10);
    putchar(x%10+'0');
}
void bfs()
{
    int i,head=0,tail=d[1]=1,x,y;
    while(head<tail)
    {
        x=d[++head];
        for(i=last[x];i;i=next[i])
        {
            y=tov[i];
            if(y!=fat[x])
            {
                fat[y]=x;
                deep[y]=deep[x]+1;
                num[y]=(i+1)/2;
                d[++tail]=y;
            }
        }
    }
}
int gef(int x)
{
    int i,top=0;
    while(x)d[++top]=x,x=fa[x];
    fo(i,1,top-1)fa[d[i]]=d[top];
    return d[i];
}
void blacken(int x,int y)
{
    while(x!=y)
    {
        if(deep[x]<deep[y])swap(x,y);
        if(deep[x=gef(x)]>=deep[y]&&x!=y)side[x-1]=i,x=fa[x]=gef(fat[x]);
    }
}
inline void ins(int t,int x,bool p)
{
    D[++tot]=mes(x,p);
    next[tot]=last[t];
    last[t]=tot;
}
int main()
{
    read(n);read(m);
    fo(i,1,n-1)
    {
        read(u);read(v);
        insert(u,v);
        insert(v,u);
    }
    bfs();
    tot=0;
    memset(next,0,sizeof next);
    memset(last,0,sizeof last);
    fo(i,1,m)
    {
        read(a[i].x);read(a[i].u);
        if(a[i].x==1)
        {
            ws++;
            ins(i,a[i].u,1);
            continue;
        }
        read(a[i].v);
        blacken(a[i].u,a[i].v);
    }
    fo(i,1,n-1)ins(side[i]?side[i]:m+1,i+1,0);
    fd(t,m+1,1)
    {
        i=last[t];
        while(i)
        {
            q[++qs].x=D[i].x;
            q[qs].t=t;
            q[qs].p=D[i].p;
            i=next[i];
        }
    }
    memset(fa,0,sizeof fa);
    fo(i,1,qs)
    {
        if(q[i].p)
        {
            f=gef(q[i].x);
            ans[ws-x++]=num[f];
            continue;
        }
        fa[q[i].x]=gef(fat[q[i].x]);
    }
    fo(i,1,x)
    {
        print(ans[i]);
        putchar(10);
    }
}