传送门

经典 $LCT$ 题，动态维护生成树

把边按边权从小到大排序，一条条加入，如果还没联通就直接连，联通了就把原本路径上最小的边替换

构成树了以后就可以更新答案了

然后问题来了，怎么动态维护整颗树的最大边权和最小边权

直接开一个 $multiset$ 就行了......

聪明的方法是用指向最小的指针加上删除标记维护

反正我比较笨就直接 $multiset$ 了...

$LCT$ 为了维护边权所以把边看成点，编号从 $n+1$ 到 $n+m$ ，原本的点为了不影响答案所以把点权置为 $INF$

具体维护的是一条链上的权值最小的点的编号

注意有自环！

 

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<set>
using namespace std;
typedef long long ll;
inline 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<<1)+(x<<3)+(ch^48); ch=getchar(); }
    return x*f;
}
const int N=1e6+7,INF=1e9+7;
int n,m,ans=233333;
struct edge{
    int a,b,w;
    inline bool operator < (const edge &tmp) const {
        return w<tmp.w;
    }
}e[N];
multiset <edge> S;
inline void upans() { if(S.size()==n-1) ans=min(ans,(*S.rbegin()).w-(*S.begin()).w); }

int c[N][2],fa[N],val[N],mi[N];
bool rev[N];
inline void pushup(int x)
{
    mi[x]=x;
    if(val[mi[x]]>val[mi[c[x][0]]]) mi[x]=mi[c[x][0]];
    if(val[mi[x]]>val[mi[c[x][1]]]) mi[x]=mi[c[x][1]];
}
inline void pushdown(int x)
{
    if(!rev[x]||!x) return;
    int &lc=c[x][0],&rc=c[x][1];
    swap(lc,rc); rev[x]=0;
    if(lc) rev[lc]^=1;
    if(rc) rev[rc]^=1;
}
inline void rever(int x) { rev[x]^=1; pushdown(x); }
inline bool noroot(int x) { return (c[fa[x]][0]==x)|(c[fa[x]][1]==x); }
inline void rotate(int x)
{
    int y=fa[x],z=fa[y],d=(c[y][1]==x);
    if(noroot(y)) c[z][c[z][1]==y]=x;
    fa[x]=z; fa[y]=x; fa[c[x][d^1]]=y;
    c[y][d]=c[x][d^1]; c[x][d^1]=y;
    pushup(y); pushup(x);
}
void push_tag(int x)
{
    if(noroot(x)) push_tag(fa[x]);
    else pushdown(x);
    pushdown(c[x][0]); pushdown(c[x][1]);
}
inline void splay(int x)
{
    push_tag(x);
    while(noroot(x))
    {
        int y=fa[x],z=fa[y];
        if(noroot(y))
        {
            if(c[y][0]==x ^ c[z][0]==y) rotate(x);
            else rotate(y);
        }
        rotate(x);
    }
}
inline void access(int x)
{
    for(int y=0;x;y=x,x=fa[x])
        splay(x),c[x][1]=y,pushup(x);
}
inline void makeroot(int x) { access(x); splay(x); rever(x); }
inline int findroot(int x)
{
    access(x); splay(x); pushdown(x);
    while(c[x][0]) x=c[x][0],pushdown(x);
    splay(x);
    return x;
}
inline int split(int x,int y) { makeroot(x); access(y); splay(y); return mi[y]; }
inline void link(int x,int y) { makeroot(x); if(findroot(y)!=x) fa[x]=y; }
inline void cut(int x,int y)
{
    makeroot(x);
    if(findroot(y)!=x||fa[y]!=x||c[y][0]) return;
    fa[y]=c[x][1]=0; pushup(x);
}

int main()
{
    n=read(),m=read();
    for(int i=0;i<=n;i++) val[i]=INF;//注意i=0
    for(int i=1;i<=m;i++) e[i].a=read(),e[i].b=read(),e[i].w=read();
    sort(e+1,e+m+1);
    for(int i=1;i<=m;i++) val[n+i]=e[i].w;
    for(int i=1;i<=m;i++)
    {
        int x=e[i].a,y=e[i].b;
        if(x==y) continue;//一定要特判自环!
        if(findroot(x)!=findroot(y)) { link(x,n+i); link(y,n+i); S.insert(e[i]); upans();/*注意一连成树就要更新答案*/ continue; }
        int t=split(x,y); cut(e[t-n].a,t); cut(e[t-n].b,t); S.erase(S.find(e[t-n]));
        link(x,n+i); link(y,n+i); S.insert(e[i]); upans();
    }
    printf("%d\n",ans);
    return 0;
}