大连赛区网赛1005 对方加一条边，我方减一条边最少的费用

/*
题意：N个点，M条无向有权边，求一个数，使得加任何一条边后，可以破坏一条小于或等于这个数的边，使得不连通
分析：先缩点形成树。而后，加上的边一定会包含最小的边权。所以分别以这条边的两端点建树。记录以某个点为根结点
的最小边权值，然后再搜一遍，确定方向。
*/
#include<stdio.h>
#include<algorithm>
#include<iostream>
using namespace std;

const __int64 maxn=11000;
const __int64 maxm=210000;
const __int64 maxint=110000000;
struct edge
{
__int64 u,v,w,next;
}e[maxm],e1[maxm];
__int64 edgeNum,top,tnum,num,first[maxn],low[maxn],DFN[maxn],belong[maxn],q[maxn];
__int64 in[maxn],lmin[maxn];
__int64 enum1,first1[maxn],sum,f,f1,f2;
bool inq[maxn];

void Addedge(__int64 u,__int64 v,__int64 w,__int64 first[],__int64 &edgeNum,edge e[])
{
e[edgeNum].u=u,e[edgeNum].v=v,e[edgeNum].w=w,e[edgeNum].next=first[u],first[u]=edgeNum++;
e[edgeNum].u=v,e[edgeNum].v=u,e[edgeNum].w=w,e[edgeNum].next=first[v],first[v]=edgeNum++;
}

void Tarjan(__int64 t,__int64 f)
{
low[t]=DFN[t]=++tnum;
q[top++]=t;
inq[t]=true;

__int64 i,k;
for(k=first[t];k!=-1;k=e[k].next)
{
i=e[k].v;
if(i==f) continue;
if(!DFN[i])
{
Tarjan(i,t);
if(low[t]>low[i])
low[t]=low[i];
}
else if(inq[i]&&low[t]>DFN[i])
low[t]=DFN[i];
}

if(low[t]==DFN[t])
{
++num;
do
{
inq[q[--top]]=false;
belong[q[top]]=num;
}while(q[top]!=t);
}
}
__int64 Min(__int64 a,__int64 b)
{
return a<b? a:b;
}
void DFS(__int64 t,__int64 p)
{
__int64 k,j,jj,ii=-1,kk=maxint;
for(k=first1[t];k!=-1;k=e1[k].next)
{
j=e1[k].v;
if(j==f1||j==f2||j==p) continue;
DFS(j,t);
jj=Min(lmin[j],e1[k].w);//子代或这条边的较小值为最小的边
if(lmin[t]>jj)
lmin[t]=jj;

if(jj<kk)
{
kk=jj;
ii=j;//记录最小的边的走向
}
}
for(k=first1[t];k!=-1;k=e1[k].next)
{
j=e1[k].v;
if(j==f1||j==f2||j==p||j==ii) continue;//不是含最小的边的子树
jj=Min(lmin[j],e1[k].w);
if(jj<sum)
sum=jj;
}
if(ii!=-1)//走向最小的边的子树
DFS(ii,t);
}

int main()
{
__int64 n,m,i,j,k,u,v,w;
while(scanf("%I64d%I64d",&n,&m)!=EOF)
{
memset(first,-1,sizeof(first));
for(edgeNum=0,i=0;i<m;i++)
{
scanf("%I64d%I64d%I64d",&u,&v,&w);
Addedge(u,v,w,first,edgeNum,e);
}

//Tarjan算法算边连通分量
memset(DFN,0,sizeof(DFN));
memset(inq,false,sizeof(inq));
memset(belong,0,sizeof(belong));
for(top=0,tnum=0,num=0,i=1;i<=n;i++)
if(!DFN[i])
Tarjan(i,-1);

//根据边连通分量缩点建树，并确定树的根结点
memset(in,0,sizeof(in));
memset(first1,-1,sizeof(first1));
for(enum1=0,j=100000000,k=-1,i=0;i<m;i++)
if(belong[e[2*i].u]!=belong[e[2*i].v])
{
Addedge(belong[e[2*i].u],belong[e[2*i].v],e[2*i].w,first1,enum1,e1);

in[belong[e[2*i].u]]++;
in[belong[e[2*i].v]]++;
if(e[2*i].w<j)
{
j=e[2*i].w;
k=2*i;
}
}

for(j=0,i=1;i<=num;i++)
{
if(in[i]==0)//注意数据有可能不连通，不加这条就会TLE
break;
if(in[i]<=1) j++;
}
if(i<=num||j<=2)//叶子结点小于或等于2个
{
printf("-1\n");
continue;
}

for(i=1;i<=num;i++)//以i为根结点的子树中最小的边权值
lmin[i]=maxint;
f1=belong[e[k].u];
f2=belong[e[k].v];
//分别以f1,f2为根结点，找第二小的路径
sum=maxint;
DFS(f1,-1);
DFS(f2,-1);
if(sum==maxint) printf("-1\n");
else printf("%I64d\n",sum);
}
return 0;
}