hdu 4005 边连通度与缩点

 

思路：先将图进行缩点，建成一颗树，那么如果这是一条单路径树（即最大点度不超过2），就不在能删的一条边，使得不连通。因为将其头尾相连，形成一个圈，那么删任意一条边，图都是连通的。

上面的是无解的情况，如果有解，那么这个解一定是树中不全在一条路径上的三条边中的一条，使得这三条边中的最大边最小，即得解。同样，对任意一个节点，其三个子树上的边一定是三条不全在一条路径上的边。问题就转化为求一个节点的第三小边。

但直接求第三小边容易出错，并且不易求得。我们可以先选一条树中的最小边，这条边一定是三条边中的一条，我们就沿着这条边的两个端点找。那么问题就又变成了求一个节点的次小边了。这个很容易求得。

感谢http://www.cnblogs.com/wuyiqi/archive/2011/11/04/2235671.html提供的测试数据。

#include<iostream>

#include<algorithm>

#include<cstring>

#include<cstdio>

#define Maxn 10010

#define Maxm 200010

#define inf 0x7fffffff

using namespace std;

int dfn[Maxn],low[Maxn],vi[Maxn],head[Maxn],Stack[Maxn],id[Maxn],degree[Maxn],lab,e,n,top,num,m,ans,wer[Maxn][2];

struct Edge{

    int u,v,next,f,val;

}edge[Maxm];

void init()

{

    memset(dfn,0,sizeof(dfn));

    memset(low,0,sizeof(low));

    memset(vi,0,sizeof(vi));

    memset(id,0,sizeof(id));

    memset(degree,0,sizeof(degree));

    memset(head,-1,sizeof(head));

    lab=top=e=num=0;

    ans=inf;

}

inline int Max(int a,int b,int c)

{

    int temp=a>b?a:b;

    return temp>c?temp:c;

}

void add(int u,int v,int val)

{

    edge[e].u=u,edge[e].v=v,edge[e].f=0,edge[e].val=val,edge[e].next=head[u],head[u]=e++;

    edge[e].u=v,edge[e].v=u,edge[e].f=0,edge[e].val=val,edge[e].next=head[v],head[v]=e++;

}

void Tarjan(int u)

{

    int i,v;

    dfn[u]=low[u]=++lab;

    Stack[top++]=u;

    vi[u]=1;

    for(i=head[u];i!=-1;i=edge[i].next)

    {

        if(edge[i].f) continue;

        edge[i].f=edge[i^1].f=1;

        v=edge[i].v;

        if(!dfn[v])

        {

            Tarjan(v);

            low[u]=min(low[u],low[v]);

        }

        if(vi[v])

            low[u]=min(low[u],dfn[v]);

    }

    if(low[u]==dfn[u])

    {

        ++num;

        do{

            i=Stack[--top];

            id[i]=num;

            vi[i]=0;

        }while(i!=u);

    }

}

int dfs(int u,int f)

{

    int i,v;

    int temp;

    wer[u][0]=wer[u][1]=inf;

    for(i=head[u];i!=-1;i=edge[i].next)

    {

        v=edge[i].v;

        if(v==f) continue;

        temp=edge[i].val;

        temp=min(temp,dfs(v,u));

        if(temp<wer[u][0])

        {

            wer[u][1]=wer[u][0];

            wer[u][0]=temp;

        }

        else

        if(temp<wer[u][1])

            wer[u][1]=temp;

        ans=min(ans,wer[u][1]);

    }

    return wer[u][0];

}

int solve()

{

    int i,j,u,v;

    Tarjan(1);

    int en=e;

    int Maxdegree=0;

    memset(head,-1,sizeof(head));

    e=0;

    int Minedge=inf,choice;

    for(i=0;i<en-1;i+=2)

    {

        u=edge[i].u,v=edge[i].v;

        if(id[u]!=id[v])

        {

            add(id[u],id[v],edge[i].val);

            if(edge[i].val<Minedge)

            {

                Minedge=edge[i].val,choice=e-1;

            }

            degree[id[u]]++,degree[id[v]]++;

            Maxdegree=Max(Maxdegree,degree[id[u]],degree[id[v]]);

        }

    }

    if(Maxdegree<=2)

        return 0;

    u=edge[choice].u,v=edge[choice].v;

    dfs(u,v);

    dfs(v,u);

    return 1;

}

int main()

{

    int i,j,a,b,c;

    while(scanf("%d%d",&n,&m)!=EOF)

    {

        init();

        for(i=1;i<=m;i++)

        {

            scanf("%d%d%d",&a,&b,&c);

            add(a,b,c);

        }

        if(!solve())

            printf("-1\n");

        else

            printf("%d\n",ans);

    }

    return 0;

}

 

/*
6
2 2
3 6
4 3
5 4
6 5
7 7
15 14
2 7
4 5
5 6
8 1
9 2
10 3
11 4
3 8
6 9
7 1
12 11
13 12
14 13
15 14
16 15
2 7
4 5
5 6
8 1
9 2
10 3
11 4
16 1
3 6
6 9
7 1
12 11
13 12
14 13
15 14
6 5
2 1
3 2
4 3
5 4
6 5
9 8
2 1
6 5
7 7
8 4
9 6
3 2
4 5
5 6
9 8
2 1
6 5
7 7
8 4
9 4
3 2
4 5
5 6
4*/