CF827D Best Edge Weight[最小生成树+树剖/LCT/(可并堆/set启发式合并+倍增)]

题意：一张图求每条边边权最多改成多少可以让所有MST都包含这条边。

---

这题还是要考察Kruskal的贪心过程。

先跑一棵MST出来。然后考虑每条边。

如果他是非树边，要让他Kruskal的时候被选入，必须要让他连的两个点$u,v$连通之前被选上，也就是说，必须得小于MST上$u,v$路径中的至少一条边，那么让他小于最大的那条（减一）即可。

如果他是树边，那么考虑如果删去他，他连接的两点如果要连通，可否用其他边替换。发现一定可以用经过这条边的非树边替换他，且会使用最小的一条非树边作为新的MST的边。所以只要找到路径覆盖这条边的所有非树边的最小的减一即可。

综上，我们需要做树上链查询$\max$，链取$\min$的操作，并且这两个操作相互独立。我一开始写了一个倍增，结果欠思考，在取$\min$操作上卡住了。。所以我重新写了一个树剖分别维护两个信息。复杂度$O(n\log^2 n)$，吊打单$\log$。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #include<queue>
 #define dbg(x) cerr << #x << " = " << x <<endl
 #define dbg2(x,y) cerr<< #x <<" = "<< x <<"  "<< #y <<" = "<< y <<endl
 using namespace std;
 typedef long long ll;
 typedef double db;
 typedef pair<int,int> pii;
 template<typename T>inline T _min(T A,T B){return A<B?A:B;}
 template<typename T>inline T _max(T A,T B){return A>B?A:B;}
 template<typename T>inline char MIN(T&A,T B){return A>B?(A=B,):;}
 template<typename T>inline char MAX(T&A,T B){return A<B?(A=B,):;}
 template<typename T>inline void _swap(T&A,T&B){A^=B^=A^=B;}
 template<typename T>inline T read(T&x){
     x=;int f=;char c;while(!isdigit(c=getchar()))if(c=='-')f=;
     while(isdigit(c))x=x*+(c&),c=getchar();return f?x=-x:x;
 }
 const int N=2e5+,INF=0x3f3f3f3f;
 struct thxorz{int to,nxt,w;}G[N<<];
 int Head[N],tot=;
 int ans[N],used[N];
 int n,m;
 inline void Addedge(int x,int y,int z){
     G[++tot].to=y,G[tot].nxt=Head[x],Head[x]=tot,G[tot].w=z;
     G[++tot].to=x,G[tot].nxt=Head[y],Head[y]=tot,G[tot].w=z;
 }
 int fa[N],topfa[N],dep[N],son[N],sum[N],pos[N],A[N],cnt;
 #define y G[j].to
 void dfs1(int x,int f){
     fa[x]=f;dep[x]=dep[G[f^].to]+;sum[x]=;int tmp=-;
     for(register int j=Head[x];j;j=G[j].nxt)if((j^)^f)dfs1(y,j),sum[x]+=sum[y],MAX(tmp,sum[y])&&(son[x]=y);
 }
 void dfs2(int x,int topf){
     topfa[x]=topf;pos[x]=cnt,A[cnt++]=G[fa[x]].w;if(!son[x])return;dfs2(son[x],topf);
     for(register int j=Head[x];j;j=G[j].nxt)if((j^)^fa[x]&&y^son[x])dfs2(y,y);
 }
 #undef y
 struct segment_tree{
     int maxv[N<<],cov[N<<],tag[N<<];
     #define lc i<<1
     #define rc i<<1|1
     segment_tree(){memset(cov,0x3f,sizeof cov),memset(tag,0x3f,sizeof tag);}
     inline void pushdown(int i){
         if(tag[i]<INF){MIN(tag[lc],tag[i]),MIN(tag[rc],tag[i]);MIN(cov[lc],tag[i]),MIN(cov[rc],tag[i]);tag[i]=INF;}
     }
     void Build(int i,int L,int R){
         if(L==R){maxv[i]=A[L];return;}
         Build(lc,L,L+R>>),Build(rc,(L+R>>)+,R);maxv[i]=_max(maxv[lc],maxv[rc]);
     }
     int UPD(int i,int L,int R,int ql,int qr,int val){
         if(ql<=L&&qr>=R){MIN(cov[i],val);MIN(tag[i],val);return maxv[i];}
         int mid=L+R>>,ret=;pushdown(i);
         if(ql<=mid)MAX(ret,UPD(lc,L,mid,ql,qr,val));
         if(qr>mid)MAX(ret,UPD(rc,mid+,R,ql,qr,val));
         cov[i]=_min(cov[lc],cov[rc]);return ret;
     }
     int Query_cover(int i,int L,int R,int x){
         if(L==R)return cov[i];
         int mid=L+R>>;pushdown(i);
         if(x<=mid)return Query_cover(lc,L,mid,x);
         return Query_cover(rc,mid+,R,x);
     }
 }T;

 struct wphorz{
     int u,v,w,id;
     inline bool operator <(const wphorz&A)const{return w<A.w;}
 }e[N];
 struct dsu{
     int anc[N];
     inline void Clear(){for(register int i=;i<=n;++i)anc[i]=i;}
     inline int Find(int x){return anc[x]==x?x:anc[x]=Find(anc[x]);}
 }S;
 inline void Kruskal(){
     sort(e+,e+m+);S.Clear();//for(register int i=1;i<=m;++i)printf("%d %d %d\n",e[i].u,e[i].v,e[i].w);
     for(register int i=;i<=m;++i)if(S.Find(e[i].u)^S.Find(e[i].v))
         S.anc[S.anc[e[i].u]]=S.anc[e[i].v],Addedge(e[i].u,e[i].v,e[i].w),used[i]=;
 }
 inline int qry_and_upd(int x,int y,int val){
     int ret=;
     while(topfa[x]^topfa[y]){
         if(dep[topfa[x]]<dep[topfa[y]])_swap(x,y);
         MAX(ret,T.UPD(,,n-,pos[topfa[x]],pos[x],val));
         x=G[fa[topfa[x]]^].to;
     }
     if(dep[x]>dep[y])_swap(x,y);
     return _max(ret,x==y?:T.UPD(,,n-,pos[x]+,pos[y],val));
 }
 inline void process(){
     for(register int i=;i<=m;++i)if(!used[i])ans[e[i].id]=qry_and_upd(e[i].u,e[i].v,e[i].w)-;
     for(register int i=;i<=m;++i)if(used[i]){//printf("%d %d\n",e[i].id,e[i].w);
         if(dep[e[i].u]<dep[e[i].v])_swap(e[i].u,e[i].v);
         ans[e[i].id]=T.Query_cover(,,n-,pos[e[i].u]);
         ans[e[i].id]<INF?ans[e[i].id]--:ans[e[i].id]=-;
     }//puts("");
     for(register int i=;i<=m;++i)printf("%d ",ans[i]);puts("");
 }

 int main(){//freopen("test.in","r",stdin);//freopen("test.ans","w",stdout);
     read(n),read(m);
     for(register int i=;i<=m;++i)read(e[i].u),read(e[i].v),read(e[i].w),e[i].id=i;
     Kruskal();dfs1(,),dfs2(,);
     T.Build(,,n-);process();
     return ;
 }

事实上，倍增那种方法也不是不可以，只不过取$\min$操作只要离线在节点上打标记，$x,y$处标记插入值，$lca$处标记删除之，然后用set维护最小值，dfs自下而上启发式合并更新即可。复杂度$O(n\log^2 n)$。还可以把set改成可并堆，然后删除的话用懒惰删除法（见lyd书），然后做到一个$\log$。

另外一种方法，直接LCT。

总结：掌握好Kruskal本质是关键。