HDU4738 Caocao's Bridges【强连通】

题意：有一张图，寻找一条边，除去这条边，其他点会分离，求这条边的最小权

思路：就是寻找割边，取权最小的割边。

坑点：1.如果图本身不连通，就不用炸了

           2.如果有割边权为0，那么还有要有人背炸药过去，ans  = 1

           3.有重边，记录从哪条边走过来

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<string>
#include<stdlib.h>
#include<math.h>
#include<vector>
#include<list>
#include<map>
#include<stack>
#include<queue>
#include<algorithm>
#include<numeric>
#include<functional>
using namespace std;
typedef long long ll;
const int maxn = 1005;

struct edge
{
	int to,next,id,val;
	bool cut;
}ed[maxn*maxn];
int head[maxn], tot;  
int Low[maxn], DFN[maxn], Stack[maxn*maxn];  
int Index, top;
bool Instack[maxn]; 
int block,belong[maxn];  
int bridge;

void init()
{
	memset(head, -1, sizeof(head));  
    memset(DFN, 0, sizeof(DFN));   
    memset(Instack, false, sizeof(Instack));   
    block = tot = 0;
    Index = top = 0;
    bridge = 0; 
}

void Tarjan(int u,int pre)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    for(int i = head[u];i != -1;i = ed[i].next)
    {
        v = ed[i].to;
        if(ed[i].id == pre) continue;
        if( !DFN[v] )
        {
            Tarjan(v,ed[i].id);
            if( Low[u] > Low[v] )Low[u] = Low[v];
            if(Low[v] > DFN[u])
            {
                bridge++;
                ed[i].cut = true;
                ed[i^1].cut = true;
            }
        }
        else if( Instack[v] && Low[u] > DFN[v] )
            Low[u] = DFN[v];
    }
    if(Low[u] == DFN[u])
    {
        block++;
        do
        {
            v = Stack[--top];
            Instack[v] = false;
            belong[v] = block;
        }
        while( v!=u );
    }
}

void add(int x,int y,int num,int w)
{
	ed[tot].to = y;
	ed[tot].next = head[x];
	ed[tot].cut = 0;
	ed[tot].val = w;
	ed[tot].id = num;
	head[x] = tot++;
}

int main(void)
{
	int n,m;
	while(scanf("%d%d",&n,&m)!=EOF && n+m)
	{
		init();
		for(int i = 1; i <= m; i++)
		{
			int a,b,w;
			scanf("%d%d%d",&a,&b,&w);
			add(a,b,i,w);
			add(b,a,i,w);	
		}
		Tarjan(1,-1);
		int flag = 0;
		for(int i = 1; i <= n; i++)
		{
			if(!DFN[i])
			{
				printf("0\n");
				flag = 1;
				break;
			}
		}
		if(flag)
			continue;
		if(block == 1)
		{
			printf("-1\n");
			continue;
		}
		int ans = 0x3f3f3f3f;
		for(int i = 1; i <= n; i++)
		{
			for(int j = head[i]; j != -1; j = ed[j].next)
			{
				if(ed[j].cut)
					ans = min(ans,ed[j].val);
			}
		}
		if(ans == 0)
			ans++;
		printf("%d\n",ans);
	}
	return 0;
}