hdu 4738 Caocao's Bridges(2013杭州网络赛丶神坑)

就是求最小权值的桥。。不过有好几个坑。。。

1：原图不连通，ans=0.

2： m<=n^2 显然有重边，重边必然不是桥，处理重边直接add(u, v, INF).

3: 最小桥边权为0的时候，ans=1，至少要派一个人运***。。。

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<fstream>
#include<sstream>
#include<map>
#include<set>
using namespace std;

const int N = 1111;
const int INF = 100000000;
int n, m;
int pre
, low
, dfs_clock;
int bccno
, vis
, wi

, g

;
struct Edge
{
    //flag = 1 ->bridge
    int from, to, w, flag;
};
vector<int> G
;
vector<Edge> edges;

//add bidir edge
void addedge(int u, int v, int w)
{
    edges.push_back((Edge){u, v, w, 0});
    edges.push_back((Edge){v, u, w, 0});
    int nima = edges.size();
    G[u].push_back(nima-2);
    G[v].push_back(nima-1);
}

int dfs(int u, int fa)
{
    int lowu = pre[u] = ++dfs_clock;
    int sz = G[u].size();
    for(int i=0; i<sz; i++)
    {
        int v = edges[G[u][i]].to;
        if(!pre[v])
        {
            int lowv = dfs(v, u);
            lowu = min(lowu, lowv);
            if(lowv > pre[u]) edges[G[u][i]].flag = 1, edges[G[u][i]^1].flag = 1;
        }
        else if(pre[v] < pre[u] && v != fa) lowu = min(lowu, pre[v]);
    }
    return low[u] = lowu;
}

void dfs1(int u)
{
    vis[u] = 1;
    int sz = G[u].size();
    for(int i=0; i<sz; i++)
    {
        Edge e = edges[G[u][i]];
        int v = e.to;
        if(!vis[v]) dfs1(v);
    }
}
int u, v, w;

int main()
{
    while(scanf("%d%d", &n, &m), n+m)
    {
        for(int i=0; i<n+1; i++) G[i].clear();
        edges.clear();
        memset(g, 0, sizeof(g));
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d", &u, &v, &w); u--; v--;
            g[u][v]++; //BIANSHU
            g[v][u]++;
            wi[u][v] = w;
        }

        //CHONG BIAN
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
            {
                if(g[i][j] == 1) addedge(i, j, wi[i][j]);
                else if(g[i][j] > 1) addedge(i, j, INF);
            }

        //BU LIANTONG
        memset(vis, 0, sizeof(vis));
        dfs1(0);
        bool flag = 0;
        for(int i=0; i<n; i++)
        {
            if(!vis[i])
            {
                flag = 1;
                break;
            }
        }
        if(flag)
        {
            puts("0");
            continue;
        }
        //QIAO
        memset(pre, 0, sizeof(pre));
        dfs_clock  = 0;
        for(int i=0; i<n; i++) if(!pre[i]) dfs(i, -1);
        int ans = INF;
        int sz = edges.size();
        for(int i=0; i<sz; i++) if(edges[i].flag == 1) ans = min(ans, edges[i].w);
        if(ans == INF) puts("-1");
        else printf("%d\n", ans == 0 ? 1 : ans); //0 -> 1
    }
    return 0;
}