HDU 4005 The war 边-双连通缩点+树形dp

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=4005

题意

在战争中，敌方有一些根据地？这些地区之间有路连接，使得所有区域可以相互通信，我方为了破坏他们的通信，也就是使图不连通，需要毁坏一条路，每条路的毁坏需要一些代价，敌人知道我方的计划，决定再加一条路，但是我方不知道，为了能让计划顺利执行，需要你来计算最少的代价。如果无法达到目的，输出-1

思路

在原图中，破坏边-双连通分量中的边不会改变图的连通性，所以首先需要边-双连通分量缩点。缩点形成的树，边权最小的边必定会被加边形成环，所以需要从边权最小边两点开始dfs建立子树，分别寻找子树中的最小边和与最小边不在同一条路径上的次小边。（敌人总是会将较小的边连成环，所以次小边不会在环上）求得的两颗子树的次小边较小这为答案

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define ll long long
using namespace std;
const int INF = ( 2e9 ) + 2;
const ll maxn = 1e5+10;
const int maxm = 2*1e5+10;
struct edge
{
    int v,w,next;
} e1[maxm],e2[maxm];
int head1[maxn],head2[maxn];
int tot1,tot2;
int dfn[maxn],low[maxn],Stack[maxn],Belong[maxn],dp[maxn];
int index,top,scc,Min;
void add1(int u,int v,int w)
{
    e1[tot1].v=v;
    e1[tot1].w=w;
    e1[tot1].next=head1[u];
    head1[u]=tot1++;
}
void add2(int u,int v,int w)
{
    e2[tot2].v=v;
    e2[tot2].w=w;
    e2[tot2].next=head2[u];
    head2[u]=tot2++;
}
void tarjan(int u,int fa)
{
    dfn[u]=low[u]=++index;
    Stack[top++]=u;
    int f=1;
    for(int i=head1[u];i!=-1;i=e1[i].next)
    {
        int v=e1[i].v;
        if(f&&v==fa)
        {
            f=0;
            continue;
        }
        if(!dfn[v])
        {
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
        }
        else
        low[u]=min(low[u],low[v]);
    }
    if(low[u]==dfn[u])
    {
        int x;
        scc++;
        do
        {
            x=Stack[--top];
            Belong[x]=scc;
        }
        while(x!=u);
    }
}
void dfs(int u,int fa)
{
    for(int i=head2[u];i!=-1;i=e2[i].next)
    {
        int v=e2[i].v;
        if(v!=fa)
        {
            dfs(v,u);
            dp[v]=min(dp[v],e2[i].w);
            if(dp[u]>dp[v])
            {
                Min=min(Min,dp[u]);
                dp[u]=dp[v];
            }
            else
            Min=min(Min,dp[v]);         
        }
    }
}
int solve(int n)
{
    memset(dfn,0,sizeof(dfn));
    index=top=scc=0;
    tarjan(1,-1);
    if(scc==1)return -1;

    int mn=INF,l,r;
    for(int i=1; i<=n; i++)
    {
        for(int j=head1[i]; j!=-1; j=e1[j].next)
        {
            int v=e1[j].v;
            if(Belong[i]!=Belong[v])
            {
                if(mn>e1[j].w)
                {
                    mn=e1[j].w;
                    l=Belong[i];
                    r=Belong[v];
                }
                add2(Belong[i],Belong[v],e1[j].w);
            }
        }
    }
    Min=INF;
    dfs(l,r);
    dfs(r,l);

    if(Min==INF)return -1;
    return Min;
}
void init(int n)
{
    memset(head1,-1,sizeof(head1));
    memset(head2,-1,sizeof(head2));
    for(int i=1;i<=n;i++)dp[i]=INF;
    tot1=tot2=0;
}
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        int u,v,w;
        init(n);
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            add1(u,v,w);
            add1(v,u,w);
        }
        printf("%d\n",solve(n));
    }
}