[并查集] UOJ#61. UR#5 怎样更有力气

这题调的我心态爆炸

大概就是可以把这条链分成若干联通块，联通块之间能连边就直接连

因为每条边只会被缩一次，所以复杂度是有保证的

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <map>
#include <set>

using namespace std;

typedef long long ll;

const int N=300010;

int n,m,p,cnt,G[N],fa[N][25],dpt[N],fat[N],nxt[N],size[N];
struct Wrk{
    int u,v,w,t;
    friend bool operator <(Wrk a,Wrk b){
        return a.w<b.w;
    }
}w[N];

struct iedge{
    int t,nx;
}E[N<<1];

inline void addedge(int x,int y){
    E[++cnt].t=y; E[cnt].nx=G[x]; G[x]=cnt;
    E[++cnt].t=x; E[cnt].nx=G[y]; G[y]=cnt;
}

void dfs(int x,int f){
    fa[x][0]=f; dpt[x]=dpt[f]+1;
    for(int i=1;i<=19;i++) fa[x][i]=fa[fa[x][i-1]][i-1];
    for(int i=G[x];i;i=E[i].nx)
        if(E[i].t!=f) dfs(E[i].t,x);
}

pair<int,int> ud[N];
int cnt0,iG[N],inxt[N];

int Gfat(int x){
    return fat[x]==x?x:fat[x]=Gfat(fat[x]);
}

int Gnxt(int x){
    return nxt[x]==x?(Gfat(x)==Gfat(fa[x][0])?nxt[x]=Gnxt(fa[x][0]):x):nxt[x]=Gnxt(nxt[x]);
}

ll ans=0;
vector<int> nd[N];

inline int lca(int x,int y){
    if(dpt[x]<dpt[y]) swap(x,y);
    for(int i=19;~i;i--)
        if(dpt[fa[x][i]]>=dpt[y]) x=fa[x][i];
    if(x==y) return x;
    for(int i=19;~i;i--)
        if(fa[x][i]!=fa[y][i]) x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}


pair<int,int> A[N],lim[N],B[N]; int tt,lt;

inline char nc(){
    static char buf[100000],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}

inline void rea(int &x){
    char c=nc(); x=0;
    for(;c>'9'||c<'0';c=nc());for(;c>='0'&&c<='9';x=x*10+c-'0',c=nc());
}

int main(){
    rea(n); rea(m); rea(p);
    for(int i=2,x;i<=n;i++)
        rea(x),addedge(x,i);
    dfs(1,0);
    for(int i=1;i<=m;i++) 
        rea(w[i].u),rea(w[i].v),rea(w[i].w),w[i].t=i;
    sort(w+1,w+1+m);
    for(int i=1,t,u,v;i<=p;i++){
        rea(t); rea(u); rea(v);
        ud[++cnt0]={u,v}; inxt[cnt0]=iG[t]; iG[t]=cnt0;
    }
    for(int i=1;i<=n;i++) fat[i]=nxt[i]=i;
    for(int i=1;i<=m;i++){
        int u=w[i].u,v=w[i].v,cur=w[i].w,LCA=lca(w[i].u,w[i].v);
        tt=0; 

        for(; Gnxt(u)!=Gnxt(LCA); u=fa[Gnxt(u)][0])
            A[++tt]={Gfat(u),dpt[u]-dpt[Gnxt(u)]+1};
        for(; Gnxt(v)!=Gnxt(LCA); v=fa[Gnxt(v)][0])
            A[++tt]={Gfat(v),dpt[v]-dpt[Gnxt(v)]+1};
        A[++tt]={Gfat(LCA),dpt[u]+dpt[v]-2*dpt[LCA]+1};
        sort(A+1,A+1+tt); int nsize=1;
        for(int i=2;i<=tt;i++)
            if(A[i].first==A[i-1].first) A[nsize].second+=A[i].second;
            else A[++nsize]=A[i];
        tt=nsize;
        lt=0; int d=w[i].t;
        for(int i=iG[d];i;i=inxt[i]){
            int u=Gfat(ud[i].first),v=Gfat(ud[i].second);
            if(u==v) continue;
            if(u<v) swap(v,u);
            lim[++lt]={u,v};
        }
        sort(lim+1,lim+1+lt);
        int k=1,cnt=0;
        for(int i=1;i<=tt;i++){
            while(lim[k].first==A[i].first && k<=lt) size[Gfat(lim[k].second)]++,k++;
            int ncnt=0,cc=0;
            for(int j=1;j<=cnt;j++){
                if(size[B[j].first]!=1LL*B[j].second*A[i].second){
                    ans+=cur; cc+=B[j].second;
                    fat[B[j].first]=A[i].first;
                }
                else{
                    B[++ncnt]=B[j];
                }
                size[B[j].first]=0;
            }
            cnt=ncnt; B[++cnt]={Gfat(A[i].first),A[i].second+cc};
        }
        //cout<<ans<<endl;
    }
    cout<<ans<<endl;
    return 0;
}