Analysis :
There are two ways to find the second smallest spanning tree. The most popular one is to find the largest edge in the ring by multiplying LCA, and here I introduce a magical O(nlogn) method:
We first establish the minimum spanning tree, because we use kruskal to solve that the size of the edges has been arranged in ascending order, so in the same case, the edge enumerated first must be better, so every time we violently find the two points connected by the non-tree edge LCA, and color the passing edges during the search process and add them to the set to prevent it from being searched twice (why only need to search once has been said before), and then at the end, we just need to find the color of the dyed color The weight of the edge represented is subtracted from the minimum value of the weight of the edge to be dyed. Because there are n-1 edges in the dyed tree, the complexity of this process is O(n), so the total complexity is the quicksort complexity O(nlogn).
Code:
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<queue>
#include<stack>
#include<map>
#include<vector>
#include<set>
#include<ctime>
#include<cctype>
using namespace std;
long long fa[110000],tot,used[310000],f[110000],col[310000],dep[110000];
long long ari[110000],is[110000];
long long sum=1;
struct node{
long long x,y,z;
}d[310000];
struct edge{
long long from,to,nxt,w,id;
}e[610000];
long long head[610000];
void add(long long x,long long y,long long z,long long id){
e[sum].to=y;
e[sum].nxt=head[x];
e[sum].w=z;
e[sum].id=id;
head[x]=sum++;
e[sum].to=x;
e[sum].nxt=head[y];
e[sum].w=z;
e[sum].id=id;
head[y]=sum++;
return;
}
bool cmp(const node &p,const node &q){
return p.z<q.z;
}
long long sf(long long a){
return fa[a]==a?a:fa[a]=sf(fa[a]);
}
void dfs(long long a,long long fat){
long long i,j,k;
for(i=head[a];i;i=e[i].nxt)
if(e[i].to!=fat){
dep[e[i].to]=dep[a]+1;
f[e[i].to]=a;
ari[e[i].to]=e[i].id;
dfs(e[i].to,a);
}
return;
}
long long ff(long long a){
return is[a]==a?a:is[a]=ff(is[a]);
}
void mer(long long u,long long v,long long c){
u=ff(u),v=ff(v);
while(u!=v){
if(dep[u]<dep[v])swap(u,v);
col[ari[u]]=c;
is[u]=ff(f[u]);
u=ff(u);
}
return;
}
int main(){
//freopen("1.in","r",stdin);
long long n,m,i,j,k;
scanf("%lld%lld",&n,&m);
for(i=1;i<=m;i++){
scanf("%lld%lld%lld",&d[i].x,&d[i].y,&d[i].z); //Build minimum spanning tree
}
sort(d+1,d+m+1,cmp);
long long cnt=0,p,q;
for(i=1;i<=n;i++){
fa[i]=i;
f[i]=i;
is[i]=i;
}
for(i=1;i<=m;i++){
p=sf(d[i].x),q=sf(d[i].y);
if(p!=q){
cnt++;
if(rand()%2)fa[p]=q;
else fa[q]=p;
tot+=d[i].z;
used[i]=1;
add(d[i].x,d[i].y,d[i].z,i);
}
if(cnt==n-1)break;
}
//初始化,f表示父子关系,is用于新并查集
dfs(1,0);
for(i=1;i<=m;i++)
if(!used[i]){
mer(d[i].x,d[i].y,i);
}
//求答案
long long ans=1000000007;
for(i=1;i<=m;i++)
if(used[i]){
if(col[i]&&d[col[i]].z!=d[i].z)
ans=min(ans,d[col[i]].z-d[i].z);
}
printf("%lld\n",ans+tot);
return 0;
}