hdu2460-Network：边的双连通分量

题目大意：给出一个无向图以及Q次询问，每次询问增加一条无向边，要求输出增加这条边后剩余的桥的数目。

算法：类似于求割点的方法，先做一次dfs求出所有的桥，并且维护这棵dfs树，当一次询问加入一条边(a,b)之后，会在dfs上形成一个环，在这个环上的桥都变为非桥，这个环肯定经过a和b的LCA，此时我们只需在求LCA的过程中把经过的为桥的树边标记为非桥，同时cnt_bridge--再输出即可。

需要注意的是树边的编号是用树边指向的那个节点的编号来表示的，例如树边<u,v>用编号v表示。

还有就是加入一个#pragma预处理指令可以防止爆栈。

 #include <iostream>
 #include <stdio.h>
 #include <cstring>
 #include <vector>
 using namespace std;
 #pragma comment(linker,"/STACk:10240000,10240000")

 const int maxn =  + ;
 int low[maxn],pre[maxn], iscut[maxn], dfs_clock=;
 bool isbridge[maxn];
 vector<int> G[maxn];
 int cnt_bridge;
 int father[maxn];

 int dfs(int u, int fa)
 {
     father[u]=fa;
     int lowu = pre[u] = ++dfs_clock;
     int child = ;
     for(int i = ; i < G[u].size(); i++)
     {
         int v = G[u][i];
         if(!pre[v])   // 没有访问过v
         {
             child++;
             int lowv = dfs(v, u);
             lowu = min(lowu, lowv); // 用后代的low函数更新自己
             if(lowv > pre[u]) // 判断边(u,v)是否为桥
             {
                 isbridge[v]=true;
                 cnt_bridge++;
             }
         }
         else if(pre[v] < pre[u] && v != fa)
         {
             lowu = min(lowu, pre[v]); // 用反向边更新自己
         }
     }
     if(fa <  && child == )
         iscut[u] = ;
     return low[u]=lowu;
 }

 void init(int n)
 {
     memset(isbridge,false,sizeof isbridge);
     memset(pre,,sizeof pre);
     cnt_bridge=dfs_clock=;
     for(int i=; i<n; i++)
     {
         G[i].clear();
     }
 }

 void LCA(int a,int b)
 {
     while(pre[a]>pre[b])
     {
         if(isbridge[a])
         {
             isbridge[a]=false;
             cnt_bridge--;
         }
         a=father[a];
     }
     while(pre[b]>pre[a])
     {
         if(isbridge[b])
         {
             isbridge[b]=false;
             cnt_bridge--;
         }
         b=father[b];
     }
     if(a!=b)
     {
         while(pre[a]>pre[b])
         {
             if(isbridge[a])
             {
                 isbridge[a]=false;
                 cnt_bridge--;
             }
             a=father[a];
         }
         while(pre[b]>pre[a])
         {
             if(isbridge[b])
             {
                 isbridge[b]=false;
                 cnt_bridge--;
             }
             b=father[b];
         }
     }
 }

 int main()
 {
 #ifndef ONLINE_JUDGE
     freopen("in.txt","r",stdin);
 #endif

     int n,m,Case=;
     while(scanf("%d %d",&n,&m),!(n== && m==))
     {
         init(n);
         for(int i=; i<m; i++)
         {
             int a,b;
             scanf("%d %d",&a,&b);
             a--;
             b--;
             G[a].push_back(b);
             G[b].push_back(a);
         }

         // 第一次dfs找出所有的桥
         dfs(,-);
         int Q;
         cin>>Q;
         printf("Case %d:\n",Case++);
         while(Q--)
         {
             int a,b;
             scanf("%d %d",&a,&b);
             a--;
             b--;
             LCA(a,b);
             printf("%d\n",cnt_bridge);
             if(Q==)
                 printf("\n");
         }
     }

     return ;
 }