（连通图）Network--POJ--3694

链接：

http://poj.org/problem?id=3694

http://acm.hust.edu.cn/vjudge/contest/view.action?cid=82833#problem/D

这部分学的不是很好，还需要努力！

代码：

 #include<cstdio>
 #include<cstdlib>
 #include<cmath>
 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 using namespace std;
 #define N 100005

 struct Edage{int v, next, used;} e[N<<];

 int low[N], dfn[N], Head[N], fa[N], Time, cnt;
 int IsBridge[N], nbridge;

 void Init(int n)
 {
     nbridge = Time = cnt = ;

     for(int i=; i<=n; i++)
     {
         Head[i] = -;
         dfn[i] = ;
         IsBridge[i] = ;
     }
 }
 void Add(int u, int v)
 {
     e[cnt].v = v;
     e[cnt].next = Head[u];
     e[cnt].used = false;
     Head[u] = cnt++;
 }
 void Tarjan(int u, int father)
 {
     int v;

     fa[u] = father;
     low[u] = dfn[u] = ++Time;

     for(int j=Head[u]; j!=-; j=e[j].next)
     {
         if(!e[j].used)
         {
             e[j].used = e[j^].used = true;
             v = e[j].v;
             if(!dfn[v])
             {
                 Tarjan(v, u);
                 low[u] = min(low[u], low[v]);

                 if(low[v]>dfn[u])
                 {
                     IsBridge[v] = true;
                     nbridge++;
                 }
             }
             else
                 low[u] = min(low[u], dfn[v]);
         }
     }
 }
 void LCA(int u, int v)
 {
     if(dfn[u]<dfn[v])
         swap(u, v);

     while(dfn[u] > dfn[v])
     {
         if(IsBridge[u]) nbridge--;
         IsBridge[u] = false;
         u = fa[u];
     }

     while(u!=v)
     {
         if(IsBridge[u]) nbridge--;
         if(IsBridge[v]) nbridge--;
         IsBridge[u] = IsBridge[v] = false;
         u = fa[u], v = fa[v];
     }
 }

 int main()
 {
     int n, m, k=;
     while(scanf("%d%d", &n, &m), n+m)
     {
         int i, u, v;

         Init(n);
         for(i=; i<m; i++)
         {
             scanf("%d%d", &u, &v);
             Add(u, v);
             Add(v, u);
         }

         Tarjan(, );

         printf("Case %d:\n", k++);
         scanf("%d", &m);
         for(i=; i<m; i++)
         {
             scanf("%d%d", &u, &v);
             LCA(u, v);
             printf("%d\n", nbridge);
         }
         printf("\n");
     }
     return ;
 }

代码：

 #include <iostream>
 #include <cstdlib>
 #include <cstdio>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <cmath>
 #include <stack>
 #include <cstring>
 usingnamespace std;
 #define INF 0xfffffff
 #define min(a,b) (a<b?a:b)
 #define maxn 100005
 int m, n, Time, ans;
 int dfn[maxn], low[maxn], Father[maxn], bridge[maxn];
 vector<int> G[maxn];

 void init()
 {
     memset(dfn, , sizeof(dfn));
     memset(low, , sizeof(low));
     memset(bridge, , sizeof(bridge));
     memset(Father, , sizeof(Father));
     Time = ans = ;

     for(int i=; i<=n; i++)
         G[i].clear();
 }

 void Tarjan(int u,int fa)
 {
     dfn[u] = low[u] = ++Time;
     Father[u] = fa;
     int len = G[u].size(), v;

     for(int i=; i<len; i++)
     {
         v = G[u][i];

         if( !low[v] )
         {
             Tarjan(v, u);
             low[u] = min(low[u], low[v]);

             if(dfn[u] < low[v])
             {
                 bridge[v] ++;
                 ans ++;
             }
         }
         elseif(v != fa)
         {
             low[u] = min(low[u], dfn[v]);

             if(dfn[u] < low[v])
             {
                 bridge[v] ++;
                 ans --;
             }
         }

     }
 }
 void Lca(int a,int b)
 {
     if(a == b)
         return ;

     if(dfn[a] > dfn[b])
     {
         if( bridge[a] == )
         {
             bridge[a] = ;
             ans --;
         }
         Lca(Father[a], b);
     }
     else
     {
         if(bridge[b] == )
         {
             bridge[b] = ;
             ans --;
         }
         Lca(a, Father[b]);
     }
 }

 int main()
 {
     int cas = ;
     while(scanf("%d %d",&n, &m), m+n)
     {
         int Q, a, b;
         init();
         while(m --)
         {
             scanf("%d %d",&a, &b);
             G[a].push_back(b);
             G[b].push_back(a);
         }

         scanf("%d", &Q);
         Tarjan(, );
     //    printf("%d\n", ans);
         printf("Case %d:\n", cas ++);
         while(Q --)
         {
             scanf("%d %d",&a, &b);
             Lca(a, b);
             printf("%d\n", ans);
         }
     }
     return0;
 }
 /*

 4 4
 1 2
 2 1
 2 3
 1 4
 2
 1 2
 3 4

   */