题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4738
题目大意：
n个岛，m条桥梁(双向)，每个桥梁有c个人。派人去炸一条桥梁（派去的人数必须>=桥梁上是人数才能炸），让图不连通。问至少需要派多少个人。如果无法完成任务输出-1。

第一行包含两个整数N和M，意味着有N个岛和M个桥。所有岛都从1到N编号。（2 <= N <= 1000,0 <M <= N^2）
接下来的M行描述了M个桥。每条线包含三个整数U，V和W，意味着有一个连接岛U和岛V的桥，并且在该桥上有W守卫。（U≠V且0 <= W <= 10,000）
输入以N = 0和M = 0结束。

对于每个样例，输出最小的人数。

思路：就是找到所有的割边。权值最小的割边就是人数。如果没有割边，输出-1，看到边的范围就知道有重边，要考虑重边，但还是WA了。

坑点：
1.权值为0，至少要派一个人去。
2.如果一开始是不连通的，输出0。

对重边的处理：
方法一：vector+map。
方法二：用新的存储方法。
方法一的复杂度比方法二多 m*lg(m) m:边数

方法一：280ms

#include<bits/stdc++.h>
#define p1 first
#define p2 second

using namespace std;
const int maxn=1000+5;
vector<pair<int, int> > v[maxn];
map<pair<int, int>, int> p;

int dfn[maxn];//dfs第一次的时间戳
int low[maxn];//能到达的最远祖先(时间戳最小)
int par[maxn];//每个点的父亲节点
int tot, n, m, MAX=(1<<31)-1;

void Tarjn(int x)
{
    low[x]=dfn[x]=++tot;//每次dfs，x的次序号增加1

    int f=0;            //记录子树的数量(特别判断根节点)
    for(int i=0;i<v[x].size();i++)//访问从x出发的边
    {
        int u=v[x][i].p1;
        if(!dfn[u])     //如果u没被访问过
        {
            f++;
            par[u]=x;   //x是u的父节点

            Tarjn(u);   //dfs(v)
            low[x]=min(low[x], low[u]);//x点和x的子树能到达的最远祖先(最小dfn)

            if(low[u]>dfn[x])//桥的条件
            {
                if(p[{x, u}]==1)
                {
                    MAX=min(MAX, v[x][i].p2);
                }
            }
        }
        else if(u!=par[x])//节点v已访问，则(u,v)为回边(指向其祖先的边),且不是重边
        {
            low[x] = min(low[x], dfn[u]);
        }

    }
}

int main()
{
    while(scanf("%d%d",&n,&m),n*m)
    {
        for(int i=0;i<maxn;i++)
        {
            v[i].clear();
        }
        p.clear();
        memset(dfn ,0, sizeof(dfn));
        memset(low, 0, sizeof(low));
        MAX=(1<<31)-1;
        tot=0;
        memset(par, -1, sizeof(par));
        for(int i=1;i<=m;i++)
        {
            int x, y, z;
            scanf("%d%d%d",&x,&y,&z);
            p[{y, x}]++;
            p[{x, y}]++;
            v[x].push_back({y, z});
            v[y].push_back({x, z});
        }
        Tarjn(1);
        int k=0;
        for(int i=1;i<=n;i++)
        {
            if(dfn[i]==0)
            {
                k=1;
                break;
            }
        }
        if(k)
        {
            cout<<0<<endl;
            continue;
        }
        if(MAX==(1<<31)-1)
        {
            cout<<-1<<endl;
        }
        else if(MAX==0)
        {
            cout<<1<<endl;
        }
        else
        {
            cout<<MAX<<endl;
        }
    }


    return 0;
}

方法二：93ms

#include<bits/stdc++.h>
using namespace std;
const int maxn=1000+5;

struct E
{
    int v, w;
    int next;

}e[maxn*maxn];
int cut=0, tot=0;
int dfn[maxn], low[maxn];
int head[maxn];
int n, m, MAX;

void into()
{
    MAX=(1<<31)-1;
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    memset(head, -1, sizeof(head));
    cut=0, tot=0;
}

int add(int u, int v, int w)
{
    e[cut].v=v;
    e[cut].w=w;
    e[cut].next=head[u];
    head[u]=cut++;
}

void T(int u, int fa, int q)
{
    dfn[u]=low[u]=++tot;
    for(int i=head[u];i!=-1;i=e[i].next)
    {
        int v=e[i].v, w=e[i].w;
        if(i==(q^1))   //消除一条反向边的影响
        {
            continue;
        }
        if(!dfn[v])
        {
            T(v, u, i);
            low[u]=min(low[u], low[v]);
            if(low[v]>dfn[u])
            {
                MAX=min(MAX, w);
            }
        }
        else
        {
            low[u]=min(low[u], dfn[v]);
        }
    }
}

int main()
{
    while(scanf("%d%d",&n,&m),n*m)
    {
        into();
        for(int i=0;i<m;i++)
        {
            int u, v, w;
            scanf("%d%d%d",&u,&v,&w);
            add(u, v, w);
            add(v, u, w);
        }
        T(1, -1, -1);
        int k=0;
        for(int i=1;i<=n;i++)
        {
            if(!dfn[i])       //原本就不连通
            {
                k=1;
                break;
            }
        }
        if(k)
        {
            cout<<0<<endl;
            continue;
        }
        if(MAX==0)           //没有人看守
        {
            cout<<1<<endl;
            continue;
        }
        if(MAX==(1<<31)-1)   //没有桥
        {
            cout<<-1<<endl;
            continue;
        }
        cout<<MAX<<endl;

    }

    return 0;
}