cf827D Best Edge Weight (kruskal+倍增lca+并查集)

先用kruskal处理出一个最小生成树

对于非树边，倍增找出两端点间的最大边权-1就是答案

对于树边，如果它能被替代，就要有一条非树边，两端点在树上的路径覆盖了这条树边，而且边权不大于这条树边

这里可以树剖来做，但是不想用..

如果先把非树边从小到大排序然后去覆盖树边，那么一条树边只需要被覆盖一次

所以可以用一个并查集来把父子边被覆盖的点合到一起，在合并之前记下来这次覆盖的边权，下次再覆盖的时候直接跳过去就可以

 #include<bits/stdc++.h>
 #define pa pair<int,int>
 #define CLR(a,x) memset(a,x,sizeof(a))
 using namespace std;
 typedef long long ll;
 const int maxn=2e5+,inf=1e9+;

 inline ll rd(){
     ll x=;char c=getchar();int neg=;
     while(c<''||c>''){if(c=='-') neg=-;c=getchar();}
     while(c>=''&&c<='') x=x*+c-'',c=getchar();
     return x*neg;
 }

 struct Edge{
     int a,b,l,ne;
     bool used;
 }eg[maxn],eg2[maxn*];
 int egh[maxn],ect;
 int N,M,fa[maxn][],bf[maxn],bm[maxn],ma[maxn][],dep[maxn];
 int ans[maxn];

 inline int getf(int x){return bf[x]==x?x:bf[x]=getf(bf[x]);}
 inline bool cmp(Edge a,Edge b){return a.l<b.l;}
 inline void adeg(int a,int b,int c){
     eg2[++ect].b=b;eg2[ect].ne=egh[a];
     eg2[ect].l=c,egh[a]=ect;
 }

 void dfs(int x){
     // printf("!!%d %d %d\n",x,fa[x][0],ma[x][0]);
     for(int i=;fa[x][i]&&fa[fa[x][i]];i++)
         fa[x][i+]=fa[fa[x][i]][i],ma[x][i+]=max(ma[x][i],ma[fa[x][i]][i]);
     for(int i=egh[x];i;i=eg2[i].ne){
         int b=eg2[i].b;
         if(b==fa[x][]) continue;
         ma[b][]=eg2[i].l;
         fa[b][]=x;dep[b]=dep[x]+;
         dfs(b);
     }
 }

 int lca(int x,int y){
     if(dep[x]<dep[y]) swap(x,y);
     int re=;
     for(int i=log2(dep[x]-dep[y]);i>=&&dep[x]!=dep[y];i--){
         if(fa[x][i]&&dep[fa[x][i]]>=dep[y])
             re=max(re,ma[x][i]),x=fa[x][i];
     }
     if(x==y) return re;
     for(int i=log2(dep[x]);i>=;i--){
         if(fa[x][i]!=fa[y][i])
             re=max(re,max(ma[x][i],ma[y][i])),x=fa[x][i],y=fa[y][i];
     }
     return max(re,max(ma[x][],ma[y][]));
 }

 int main(){
     //freopen("","r",stdin);
     int i,j,k;
     N=rd(),M=rd();
     for(i=;i<=M;i++){
         eg[i].a=rd(),eg[i].b=rd(),eg[i].l=rd();
         eg[i].ne=i;
     }
     sort(eg+,eg+M+,cmp);
     for(i=;i<=N;i++) bf[i]=i;
     for(i=,j=;i<=M&&j<N-;i++){
         int a=getf(eg[i].a),b=getf(eg[i].b);
         if(a!=b){
             bf[a]=b;
             adeg(eg[i].a,eg[i].b,eg[i].l);
             adeg(eg[i].b,eg[i].a,eg[i].l);
             eg[i].l=inf;eg[i].used=;
             j++;
         }
     }
     dep[]=;dfs();
     sort(eg+,eg+M+,cmp);
     for(i=;i<=N;i++) bf[i]=i,bm[i]=inf;
     for(i=;i<=M;i++){
         if(eg[i].used) continue;
         int a=getf(eg[i].a),b=getf(eg[i].b);
         while(a!=b){
             if(dep[a]<dep[b]) swap(a,b);
             int bb=getf(fa[a][]);
             bf[a]=bb,bm[a]=eg[i].l;
             a=bb;
         }
     }
     for(i=;i<=M;i++){
         if(eg[i].used){
             int a=eg[i].a,b=eg[i].b;
             if(dep[a]<dep[b]) swap(a,b);
             // a=getf(a),b=getf(b);
             if(bm[a]<inf) ans[eg[i].ne]=bm[a]-;
             else ans[eg[i].ne]=-;
         }else{
             ans[eg[i].ne]=lca(eg[i].a,eg[i].b)-;
         }
     }
     for(i=;i<=M;i++)
         printf("%d ",ans[i]);
     return ;
 }