BZOJ 3319: 黑白树 并查集 + 离线 + 思维

Description

给定一棵树，边的颜色为黑或白，初始时全部为白色。维护两个操作：

1.查询u到根路径上的第一条黑色边的标号。

2.将u到v    路径上的所有边的颜色设为黑色。

Notice:这棵树的根节点为1

Input

第一行两个数n,m分别表示点数和操作数。

接下来n-1行，每行2个数u,v.表示一条u到v的边。

接下来m行，每行为以下格式：

1 v 表示第一个操作

2 v u 表示第二种操作

n，m<=10^6

Output

对于每个询问，输出相应答案。如果不存在，输出0

题解：我们将边下放到点，用点的标号来代指边

看完题面后有一个想法：用并查集维护每个白点所能到达的第一个黑点
我们知道，并查集是向上合并的
如果正着做，每一次将一条路径染黑，会导致很多白点的祖先改变，而且是向下变
向下变就十分麻烦，非常不好做
不妨逆着操作，记录每一个节点变黑的最早时间，将操作逆着进行
可以先将整棵树全部染黑，逆着逐渐染白，那么每个白点的祖先只会更向上，向上合并
比如当前要将点 $x$ 染白，那么 $x$ 子树中的白点在改动前并查集指向的祖先都是 $x$
在改动后 $x$ 的祖先会向上合并，而 $x$ 子树中的白点在并查集查祖先时查到 $x$ 的话会顺着 $x$ 向上合并到的祖先继续向上查询

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<map>
#include<vector>
#include<stack>
#include<queue>
#define setIO(s) freopen(s".in","r",stdin),freopen(s".out","w",stdout)  
#define maxn 1002002
using namespace std;  
char *p1,*p2,buf[100000];
#define nc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++)
int rd() {int x=0; char c=nc(); while(c<48) c=nc(); while(c>47) x=(((x<<2)+x)<<1)+(c^48),c=nc(); return x;}
vector<int>G[maxn]; 
stack<int>S;                  
int n,m,edges; 
int tm[maxn],hd[maxn<<1],to[maxn<<1],nex[maxn<<1];     
int siz[maxn],top[maxn],fa[maxn],dep[maxn],son[maxn]; 
int idx[maxn<<1],id[maxn<<1];     
inline void addedge(int u,int v,int c) {
    nex[++edges]=hd[u],hd[u]=edges,to[edges]=v, id[edges]=c;   
}
void dfs1(int u,int ff) {
    dep[u]=dep[ff]+1,siz[u]=1,fa[u]=ff; 
    for(int i=hd[u];i;i=nex[i]) {
        int v=to[i];     
        if(v==ff) continue; 
        idx[v]=id[i], dfs1(v,u), siz[u]+=siz[v]; 
        if(siz[v] > siz[son[u]]) son[u] = v;  
    }
}
void dfs2(int u,int tp) {
    top[u]=tp; 
    if(son[u]) dfs2(son[u], tp); 
    for(int i=hd[u];i;i=nex[i]) {
        int v=to[i]; 
        if(v==fa[u] || v==son[u]) continue; 
        dfs2(v,v); 
    }
}
inline int LCA(int x,int y) {
    while(top[x]^top[y]) {
        dep[top[x]]>dep[top[y]]?x=fa[top[x]]:y=fa[top[y]]; 
    }
    return dep[x]<dep[y]?x:y; 
}
struct Opt {
    int opt,x,y;
}op[maxn]; 
struct Union {
    int p[maxn]; 
    inline void init() {
        for(int i=0;i<maxn;++i) p[i]=i; 
    }
    int find(int x) {
        return p[x]==x?x:p[x]=find(p[x]); 
    }
}black,white;         
inline void mark(int u,int lca,int cur) {
    u=tm[u]?black.find(u):u;  
    while(dep[u]>dep[lca]) {
        tm[u]=cur;      
        if(!tm[fa[u]]) {
            black.p[u]=fa[u];   
            u=fa[u];   
        }    
        else {
            int y=black.find(fa[u]);          
            black.p[u]=y;          
            u=y;                  
        }
    }
}
inline void update(int u,int v,int cur) {
    int lca=LCA(u,v); 
    mark(u,lca,cur), mark(v,lca,cur);     
}
inline void change(int u) {
    white.p[u]=white.find(fa[u]);                
}
int main() {
    // setIO("input"); 
    scanf("%d%d",&n,&m); 
    for(int i=1;i<n;++i) {
        int u,v; 
        u=rd(),v=rd(); 
        addedge(u,v,i),addedge(v,u,i);         
    }
    dfs1(1,0), dfs2(1,1), black.init();                      
    for(int i=1;i<=m;++i) {
        op[i].opt=rd(); 
        if(op[i].opt==1) op[i].x=rd(); 
        if(op[i].opt==2) op[i].x=rd(), op[i].y=rd(), update(op[i].x,op[i].y,i);  
    }   
    white.init(); 
    for(int i=2;i<=n;++i) G[tm[i]==0?m+1:tm[i]].push_back(i);  
    m+=(G[m+1].size()>1); 
    for(int i=m;i>=1;--i) {      
        if(G[i].size()) {
            for(int j=0;j<G[i].size();++j) change(G[i][j]);        
        }else if(op[i].opt==1) {
            S.push(white.find(op[i].x));                 
        }
    }             
    while(!S.empty()) {
        printf("%d\n",idx[S.top()]); S.pop(); 
    }
    return 0; 
}