思路分析
具体思路都在两位巨佬的题解中。这题做法挺多的，我就不对每个都详细讲了，泛泛而谈吧。
首先kruskal把最小生成树弄出来，因为要求次小生成树。至于为什么次小一定只在最小的基础上改变了一条边，我也不会证。。。。。。打表找规律大法好
剩下的可以有一堆数据结构来维护最大值和次大值（原理两位巨佬都讲清楚了，这里只分析一下算法的优劣）
- 倍增+LCA
山楠巨佬的做法，我也写了这一种。复杂度\(O(MlogM(kruscal)+MlogN(\)倍增\(+LCA))\)常数较小，思路简单，详见山楠巨佬的题解。缺点是容易写挂，尤其是倍增部分。。。。。。（我写了半个上午+大半个下午）
还要注意维护最大值和次大值的倍增状态转移，具体详见最下方的代码。 - 树剖+LCA
思路也很简单（跟上面差不多），模板好背些（但不好打），然而我并不会。只不过复杂度为\(O(MlogM+Mlog^2N)\)，常数也不够小，难以接受。。。。。。 - LCT
思路还是很简单，拆点维护边权（LCT总结持续更新中），每次挑出两个点split一下来查询最大/次大值。复杂度正确\(O(MlogM+MlogN)\)，但常数巨大（天平巨佬和XZY巨佬都被卡了。。。。。。），搞得我不敢做。。。。。。 - 主席树+LCA
自己yy出来的，只是未实现。毕竟用到这一题上面还是有点大材小用了。
参考一下count on a tree这道题和我的题解。
同样对于最小生成树边权按降序离散化后，建立主席树（并不用拆点，以点权作为点的父边的边权），查询跳\(u,v,lca(u,v)\)三个点，算\(size[lc[u]]+size[lc[v]]-2×size[lc[lca]]\)。我们不查排名了，直接找排名最小的值，能往左跳（上式结果大于0）就往左，假如最大值等于当前枚举到的边权（不能构成严格次小生成树），就return回去找次大值。复杂度正确，\(O(MlogM+MlogN)\)，常数应该也不错（没有二维数组），但比方法1估计还是要低效一点（查询是满的log，方法1基本不满） （蒟蒻闲扯中，求Dalao勿喷）
我很希望，用一种贪心的思想来去掉前面除kruskal部分以外的log复杂度。因为边集已经排好序，我们算答案的时候，后面的权值一定大于等于前面，算贡献的时候可以贪心。于是想暴力查询并维护已查询的边，下次查的时候就利用之前的信息就好了。
这样对于非严格次小生成树是可做的，非常贪心，找完的最小生成树边，算完贡献就删掉了。因为后面枚举到的非最小生成树边，在找的最小生成树边中，假如当前找到一个以前找过的最小生成树边，那么当前产生的贡献一定小于等于以前产生的贡献。所以删掉就没问题啦！
但是，这里要求是严格次小，那我们在找的时候，可能有某个最小生成树边严格等于当前枚举到的非树边，那么当前不能算贡献，但以后可以啊！
那么可不可以暂时先不删掉这些当前严格等于的边呢？这样是对的，但是假如构造出一组数据，使得绝大部分边权值完全一样，那么每一次枚举非树边都不能删掉，复杂度退化到\(O(N(M-N))\)，不敢这样做（但愿数据较水，不卡这种方法）
还有可能可以维护以前查询过的最大值。但我还是太弱了，并没有想到很好的能仅仅以线性时间复杂度的代价就能维护此信息的方法，Dalao们有想法欢迎指教。
又看到不少巨佬被卡常了，于是我又打算拿这题来练练卡常技巧。效果很不错，没开氧气就到rank1了。还是分享一下吧。
register，inline，fread是不能少的。另外，ST表是个二位数组，调用需要较大常数。我们发此题倍增需要维护3个量（每个点的\(2^j\)的祖先（用于LCA)，到这个祖先路径上的边权最大值、次大值），而且不管是预处理还是查询的时候，三个量都是捆绑在一起的。于是我干脆把他们放在一个struct里面了。然后开一个临时register指针指向当前的维度，防止反复调用二位数组。大概就是这样，我也没法很清楚地描述，看看代码吧。
#include<cstdio>
#include<algorithm>
using namespace std;
#define R register
#define max(x,y) x>y?x:y//返回最大值
#define maxp(x,y) if(x<y)x=y;//更新最大值
#define in(z) while(*++p<‘-‘); z=*p&15; while(*++p>‘-‘)z*=10,z+=*p&15//读优
const int N=100009,M=300009;
long long sum;//注意不能开int
char s[M<<5];
bool mst[M];
int P,he[N],ne[N<<1],to[N<<1],len[N<<1],ff[N],b[N],d[N];
struct ST{
int f,m1,m2;
}st[N][18];//封起来
struct EDGE{
int u,v,l;
inline bool operator<(EDGE x)const{//用于sort
return l<x.l;
}
inline void add(){//将该边加入最小生成树
sum+=l;
to[++P]=v;ne[P]=he[u];he[u]=P;len[P]=l;
to[++P]=u;ne[P]=he[v];he[v]=P;len[P]=l;
}
}e[M];
void dfs(R int u,R int fa){//建树，预处理
d[u]=d[fa]+1;
st[u][0].f=fa;
R ST*a,*l,*r;//卡常指针,a总区间,l上区间,r下区间
//可忽略下面一行（极其丑陋）
for(R int&i=b[u];((a=&st[u][i+1])->f=(l=&st[(r=&st[u][i])->f][i])->f);++i){
if(l->m1>r->m1)a->m1=l->m1,a->m2=max(l->m2,r->m1);
else if(r->m1>l->m1)a->m1=r->m1,a->m2=max(r->m2,l->m1);
else a->m1=l->m1,a->m2=max(l->m2,r->m2);//注意认真分析最大和次大的转移
}
for(R int i=he[u];i;i=ne[i])
if(to[i]!=fa)st[to[i]][0].m1=len[i],dfs(to[i],u);
}
int getf(R int x){//并查集
if(x!=ff[x])return ff[x]=getf(ff[x]);
return x;
}
int main(){
fread(s,1,sizeof(s),stdin);//卡常
R char*p=s-1;//再卡常
R ST*l,*r;//还是卡常
R int n,m,i,j,k,x,y,now,nl,ans=2147483647;
in(n);in(m);
for(i=1;i<=m;++i){
in(e[i].u);in(e[i].v);in(e[i].l);
}
//kruscal开始
sort(e+1,e+m+1);
for(i=1;i<=n;++i)ff[i]=i;
for(i=1;P>>1<n-1;++i){
x=getf(ff[e[i].u]);y=getf(ff[e[i].v]);
if(x==y)continue;
mst[i]=1;//标记为树边
ff[x]=y;
e[i].add();
}
dfs(1,0);
for(i=1;i<=m;++i){
if(mst[i])continue;
x=e[i].u;y=e[i].v;now=0;nl=e[i].l;
//倍增，跳LCA以及更新当前最大贡献
if(d[x]<d[y])j=x,x=y,y=j;
for(j=0,k=d[x]-d[y];k;++j,k>>=1){//调整至深度相同
if(k&1){
if((l=&st[x][j])->m1!=nl){maxp(now,l->m1);}
else{maxp(now,l->m2);}
x=l->f;
}
}
if(x==y)goto F;//不用跳LCA了，下面直接跳过
for(j=b[x];j>=0;--j){
if((l=&st[x][j])->f==(r=&st[y][j])->f)continue;
if(l->m1!=nl){maxp(now,l->m1);}
else{maxp(now,l->m2);}//判断用最大还是次大更新
if(r->m1!=nl){maxp(now,r->m1);}
else{maxp(now,r->m2);}
x=l->f;y=r->f;
}
//注意下面几行，还没跳到LCA上，还要算父边有没有贡献（害我WA了N回）
if((l=&st[x][0])->m1!=nl){maxp(now,l->m1);}
else{maxp(now,l->m2);}
if((r=&st[y][0])->m1!=nl){maxp(now,r->m1);}
else{maxp(now,r->m2);}
F:if(ans>nl-now)ans=nl-now;
}
printf("%lld\n",sum+ans);
return 0;
}