冷战

题目大意

有两种操作，添加一条边或者询问两点在哪次操作后联通。
强制在线。

辣鸡LCT

一条边的权值是其的加入时间。
询问操作便是询问路径上的最大值。
我们不会维护边权，因此可以把边变成的点，向两端连边。
愉快被卡常。

#include<cstdio>
#include<algorithm>
#define fo(i,a,b) for(i=a;i<=b;i++)
using namespace std;
const int maxn=500000+10;
int pp[maxn*2],key[maxn*2],fa[maxn*2],num[maxn*2],tree[maxn*2][2];
bool bz[maxn*2];
int father[maxn],s[maxn*2];
int i,j,k,l,t,n,m,tot,top,cnt,ans;
bool czy;
int read(){
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9'){
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9'){
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x*f;
}
int getfather(int x){
    return father[x]?father[x]=getfather(father[x]):x;
}
void mark(int x){
    bz[x]^=1;
    swap(tree[x][0],tree[x][1]);
}
void down(int x){
    if (bz[x]){
        if (tree[x][0]) mark(tree[x][0]);
        if (tree[x][1]) mark(tree[x][1]);
        bz[x]=0;
    }
}
void update(int x){
    num[x]=key[x];
    if (tree[x][0]) num[x]=max(num[x],num[tree[x][0]]);
    if (tree[x][1]) num[x]=max(num[x],num[tree[x][1]]);
}
int pd(int x){
    return tree[fa[x]][1]==x;
}
void rotate(int x){
    int y=fa[x],z=pd(x);
    fa[x]=fa[y];
    if (fa[y]) tree[fa[y]][pd(y)]=x;
    tree[y][z]=tree[x][1-z];
    if (tree[x][1-z]) fa[tree[x][1-z]]=y;
    fa[y]=x;
    tree[x][1-z]=y;
    update(y);
    update(x);
    if (pp[y]){
        pp[x]=pp[y];
        pp[y]=0;
    }
}
void remove(int x,int y){
    top=0;
    while (x!=y){
        s[++top]=x;
        x=fa[x];
    }
    while (top){
        down(s[top]);
        top--;
    }
}
void splay(int x,int y){
    remove(x,y);
    while (fa[x]!=y){
        if (fa[fa[x]]!=y)
            if (pd(x)==pd(fa[x])) rotate(fa[x]);else rotate(x);
        rotate(x);
    }
}
void access(int x){
    splay(x,0);
    if (tree[x][1]){
        fa[tree[x][1]]=0;
        pp[tree[x][1]]=x;
    }
    tree[x][1]=0;
    update(x);
    int y;
    while (pp[x]){
        y=pp[x];
        splay(y,0);
        if (tree[y][1]){
            fa[tree[y][1]]=0;
            pp[tree[y][1]]=y;
        }
        tree[y][1]=x;
        pp[x]=0;
        fa[x]=y;
        update(y);
        x=y;
    }
}
void makeroot(int x){
    access(x);
    splay(x,0);
    mark(x);
}
int main(){
    freopen("coldwar.in","r",stdin);freopen("coldwar.out","w",stdout);
    czy=1;
    tot=n=read();m=read();
    while (m--){
        t=read();j=read();k=read();
        if (czy) j^=ans,k^=ans;
        if (!t){
            cnt++;
            if (getfather(j)!=getfather(k)){
                father[getfather(j)]=getfather(k);
                makeroot(k);
                makeroot(j);
                key[++tot]=cnt;
                num[tot]=cnt;
                pp[tot]=k;
                splay(j,0);
                pp[j]=tot;
            }
        }
        else{
            if (getfather(j)!=getfather(k)) ans=0;
            else{
                makeroot(k);
                access(j);
                splay(j,0);
                ans=num[j];
            }
            printf("%d\n",ans);
        }
    }
}

并查集

我们思索，不进行路径压缩的并查集中每一条边都将两个集合拼接在一起。
如果并查集中边的边权即为将这两个集合链接起来的操作对应边的序号（有点绕，其实就是LCT方法的边权）。
那么我们知道，j到k在并查集上的路径所经过的边的最大值也就是答案！
按秩合并就好，按秩合并就是高度小的合进高度大的。

#include<cstdio>
#include<algorithm>
#define fo(i,a,b) for(i=a;i<=b;i++)
using namespace std;
const int maxn=500000+10;
int fa[maxn],rank[maxn],data[maxn];
bool bz[maxn];
int i,j,k,l,t,n,m,tot,cnt,ans;
bool czy;
int read(){
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9'){
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9'){
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x*f;
}
int getfa(int x){
    while (fa[x]) x=fa[x];
    return x;
}
int merge(int x,int y,int z){
    if (rank[x]>rank[y]) swap(x,y);
    fa[x]=y;
    data[x]=z;
    if (rank[x]==rank[y]) rank[y]++;
}
int main(){
    freopen("coldwar.in","r",stdin);freopen("coldwar.out","w",stdout);
    czy=1;
    n=read();m=read();
    fo(i,1,n) rank[i]=1;
    while (m--){
        t=read();j=read();k=read();
        if (czy) j^=ans,k^=ans;
        if (!t){
            cnt++;
            j=getfa(j);
            k=getfa(k);
            if (j!=k) merge(j,k,cnt);
        }
        else{
            ans=0;
            if (getfa(j)==getfa(k)){
                t=j;
                while (t){
                    bz[t]=1;
                    t=fa[t];
                }
                t=k;
                while (!bz[t]) t=fa[t];
                l=j;
                while (l){
                    bz[l]=0;
                    l=fa[l];
                }
                while (j!=t){
                    ans=max(ans,data[j]);
                    j=fa[j];
                }
                while (k!=t){
                    ans=max(ans,data[k]);
                    k=fa[k];
                }
            }
            printf("%d\n",ans);
        }
    }
}