Hdu 4738 Caocao's Bridges （连通图+桥）

题目链接：

　　Hdu 4738 Caocao's Bridges

题目描述：

　　有n个岛屿，m个桥，问是否可以去掉一个花费最小的桥，使得岛屿边的不连通？

解题思路：

　　去掉一个边使得岛屿不连通，那么去掉的这个边一定是一个桥，所以我们只需要求出来所有的桥，然后比较每个桥的花费，选取最小的那个就好。

看起来很简单的样子哦！但是这个题目有很多的细节：

　　A：题目中有重边，以后写Tarjan还是清一色判断重边吧。（除非题目特别要求）

　　B：m个桥有可能连通不了这n个桥，这个时候不需要花费。

　　C：当最小花费桥的花费是0的话，应该输出1。

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 typedef long long LL;
 const int maxn = ;
 const int INF = 0x3f3f3f3f;
 struct node
 {
     int to, next, num;
 } edge[maxn*maxn];
 int head[maxn], low[maxn], dfn[maxn], stack[maxn];
 int id[maxn], cnt, tot, top, ntime;

 void init ()
 {
     cnt = tot = top = ntime = ;
     memset (id, , sizeof(id));
     memset (low, , sizeof(low));
     memset (dfn, , sizeof(dfn));
     memset (head, -, sizeof(head));
     memset (stack, , sizeof(stack));
 }
 void Add (int from, int to, int num)
 {
     edge[tot].to = to;
     edge[tot].num = num;
     edge[tot].next = head[from];
     head[from] = tot ++;
 }
 void Tarjan (int u, int father)
 {
     int k = ;
     low[u] = dfn[u] = ++ntime;
     stack[top++] = u;
     for (int i=head[u]; i!=-; i=edge[i].next)
     {
         int v = edge[i].to;
         if (v == father && !k)
         {
             k ++;
             continue;
         }
         if (!dfn[v])
         {
             Tarjan (v, u);
             low[u] = min (low[u], low[v]);
         }
         else
             low[u] = min (low[u], dfn[v]);
     }
     if (low[u] == dfn[u])
     {
         cnt ++;
         while ()
         {
             int v = stack[--top];
             id[v] = cnt;
             if (v == u)
                 break;
         }
     }
 }
 void solve (int n)
 {
     int mini = INF, k = ;
     for (int i=; i<=n; i++)
         if (!dfn[i])
         {
             k ++;
             Tarjan(i, );
         }
     if (cnt == )
     {
         printf ("-1\n");
         return ;
     }
     if (k > )
     {
         printf ("0\n");
         return ;
     }
     for (int i=; i<=n; i++)
         for (int j=head[i]; j!=-; j=edge[j].next)
         {
             int u = id[i];
             int v = id[edge[j].to];
             if (u != v && mini > edge[j].num)
                 mini = edge[j].num;
         }
     if (mini == )
         mini ++;
     printf("%d\n", mini);
 }
 int main ()
 {
     int n, m;
     while (scanf ("%d %d", &n, &m), n+m)
     {
         int u, v, num;
         init ();
         while (m --)
         {
             scanf ("%d %d %d", &u, &v, &num);
             Add (u, v, num);
             Add (v, u, num);
         }
         solve (n);
     }
     return ;
 }