POJ 3694 Network ——（桥 + LCA）

　　题意：给n个点和m条边，再给出q条边，问每次加一条边以后剩下多少桥。

　　分析：这题是结合了LCA和dfn的妙用。_dfn数组和dfn的意义不一样，并非访问的时间戳，_dfn表示的是被访问的顺序，而且是多线程访问下的顺序，举个例子，同一个点分岔开来的点，距离这个点相同距离的点，他们的_dfn的值是相同的，而dfn不是，类似于单线程dfs访问的各点的dfn值是不同的。

　　具体见代码：　　

 #include <stdio.h>
 #include <algorithm>
 #include <string.h>
 #include <map>
 #include <vector>
 #include <queue>
 using namespace std;
 const int N =  + ;

 int n,m,tot,head[N],cnt,dfs_clock,dfn[N],_dfn[N],root[N],low[N];
 bool bridge[N];
 struct edge
 {
     int nxt,v;
 }edges[N<<];

 void init()
 {
     tot = ,dfs_clock = ,cnt = ;
     memset(head,-,sizeof(head));
     memset(dfn,,sizeof(dfn));
     memset(_dfn,,sizeof(_dfn));
     memset(bridge,false,sizeof(bridge));
     for(int i=;i<=n;i++) root[i] = i;
 }

 void addEdge(int u,int v)
 {
     edges[tot] = (edge){head[u],v};
     head[u] = tot ++;
     edges[tot] = (edge){head[v],u};
     head[v] = tot ++;
 }

 void tarjan(int u)
 {
     dfn[u] = low[u] = ++dfs_clock;
     _dfn[u] = _dfn[root[u]] + ;
     for(int i=head[u];i!=-;i=edges[i].nxt)
     {
         edge &e = edges[i];
         int v = e.v;
         if(!dfn[v])
         {
             root[v] = u;
             tarjan(v);
             low[u] = min(low[u],low[v]);
             if(low[v] > dfn[u])
             {
                 cnt ++;
                 bridge[v] = true;
             }
         }
         else if(dfn[v] < dfn[u] && v!=root[u]) low[u] = min(low[u],dfn[v]);
     }
 }

 void LCA(int u,int v)
 {
     while(_dfn[u] > _dfn[v])
     {
         if(bridge[u])
         {
             cnt --;
             bridge[u]  = false;
         }
         u = root[u];
     }
     while(_dfn[u] < _dfn[v])
     {
         if(bridge[v])
         {
             cnt --;
             bridge[v] = false;
         }
         v = root[v];
     }
     while(u != v)
     {
         if(bridge[u])
         {
             cnt --;
             bridge[u] = false;
         }
         if(bridge[v])
         {
             cnt --;
             bridge[v] = false;
         }
         u = root[u];
         v = root[v];
     }
 }

 void solve()
 {
     for(int i=;i<=n;i++) if(!dfn[i]) tarjan(i);

     int q;scanf("%d",&q);
     while(q--)
     {
         int u,v;scanf("%d%d",&u,&v);
         LCA(u,v);
         printf("%d\n",cnt);
     }
     puts("");
 }

 int main()
 {
     int kase = ;
     while(scanf("%d%d",&n,&m)==)
     {
         if(n== && m==) break;
         init();
         printf("Case %d:\n",kase++);
         while(m--)
         {
             int u,v;scanf("%d%d",&u,&v);
             addEdge(u,v);
         }
         solve();
     }
 }