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 = 100000 + 10;
int low[maxn],pre[maxn], iscut[maxn], dfs_clock=0;
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 = 0;
    for(int i = 0; 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 < 0 && child == 1)
        iscut[u] = 0;
    return low[u]=lowu;
}

void init(int n)
{
    memset(isbridge,false,sizeof isbridge);
    memset(pre,0,sizeof pre);
    cnt_bridge=dfs_clock=0;
    for(int i=0; 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=1;
    while(scanf("%d %d",&n,&m),!(n==0 && m==0))
    {
        init(n);
        for(int i=0; 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(0,-1);
        int Q;
        cin>>Q;
        printf("Case %d:
",Case++);
        while(Q--)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            a--;
            b--;
            LCA(a,b);
            printf("%d
",cnt_bridge);
            if(Q==0)
                printf("
");
        }
    }

    return 0;
}