hdu 2460 tarjen Network

题意：给你一个无向连通图，让后给出每给q条要添加的边，输出添加每一条边之后图中还剩下多少桥

分析：向图中加入边那么就有可能是得图中的桥减小，那么我们可以先求出图中的双连通分量，那么若添加的一条边是属于某个双连通分量的那么桥的条数没有减少，如果这条边的两个顶点分别属于两个双连通子图，那么从就会使桥的数目减小，那么问题就分为两步来解决： 1、求出双连通分量后和缩点 2、加入一条边后求出桥减少的条数

第一步很好解决，这里就不赘述！

第二步：因为缩点之后新图就是一颗树，向该树中添加一条边，那么树中就会形成一条环（就形成了一个双连通分量），那么这个环上的边（当然不包含添加的那条边）就是减少的桥的条数，那么我们现在的任务就是找出加边之后形成的环中的边，那么我们可以用暴力lca

而且重点是要搞个手写栈。。。（不是搞图论的，代码是韦广的。大致搞明白是个什么意思。）

#pragma comment(linker, "/STACK:10240000000000,10240000000000")
#include <iostream>
#include <vector>
#include <stack>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn=110009;
const int M=210005;
int low[maxn];
int dfn[maxn];
int n,m;
vector<int>p[maxn];
stack<int>s;
int aa,bb;
int qu;
int vis[maxn];
int fa[maxn];
int b[maxn];
int tmp=1;
int ecnt;
/*void tarjan(int u)
{
    visit[u]=1;
    dfn[u]=low[u]=tmp++;
    for(int i=0; i<p[u].size(); i++)
    {
        int v=p[u][i];
        if(!visit[v])
        {
            fa[v]=u;
            tarjan(v);
            low[u]=min(low[u],low[v]);
            if(low[v]>dfn[u])
            {
                cnt++;
                b[v]=1;
            }
        }
        else if(v != fa[u] && visit[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
}
*/
struct Node
{
    int u,v,next;
} edge[maxn*10];

int head[maxn];
int cnt;
void init()
{
    tmp=1;
    for(int i=1; i<=n; i++)
     fa[i]=i;
    memset(b,0,sizeof(b));
    memset(vis,0,sizeof(vis));
    cnt=1;
    ecnt=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v)
{
        if(u==v)return;
        edge[ecnt].u = u;
        edge[ecnt].v = v;
        edge[ecnt].next = head[u];
        head[u] = ecnt++;
}

int tp;
int cur[maxn];
int st[maxn*10];

void tarjan()//对一个图得出dfn和low，dfn表示这个点在第几层，low表示这个点的父亲在第几层
{
    for(int i = 1; i < maxn; ++ i)
        cur[i] = head[i];
    st[++tp] = 1;
    while(tp)
    {
        int k = st[tp];
        if(!vis[k])
        {
            dfn[k] = low[k] =  tmp++;
            vis[k] = 1;
        }
        for(; cur[k]!=-1; cur[k]=edge[cur[k]].next)
        {
            int v = edge[cur[k]].v;
            if(!vis[v])
            {
                fa[v] = k;
                break;
            }
            else if(vis[v]==1&&v!=fa[k])
                low[k]=min(dfn[v],low[k]);
        }
        if((cur[k]==-1)&&tp>1)
        {
            low[st[tp-1]] = min(low[k],low[st[tp-1]]);
            if(low[k]>dfn[st[tp-1]])
            {
                b[k] = 1;//记录k到父亲的这条边是割边
                cnt++;//记录割边的加加
            }
        }
        if(cur[k]==-1)
        {
            vis[k] = 2;
            tp--;
        }
        else st[++tp] = edge[cur[k]].v;
    }
}

void LCA(int u,int v)//找公共祖先的同时求割边
{
    while(dfn[u]>dfn[v])
    {
        if(b[u])
        {
            cnt--;
            b[u]=0;//加了边之后就不是割边了
        }
        u=fa[u];
    }
    while(dfn[v]>dfn[u])
    {
        if(b[v])
        {
            cnt--;
            b[v]=0;
        }
        v=fa[v];
    }
    while(v!=u)
    {
        if(b[u])
        {
            cnt--;
            b[u] = 0;
        }
        if(b[v])
        {
            cnt--;
            b[v] = 0;
        }
        u = fa[u];
        v = fa[v];
    }
}
int main()
{
    int cas=1;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(!n&&!m)break;
        init();
        for(int i=0; i<m; i++)
        {
            scanf("%d%d",&aa,&bb);
            addedge(aa,bb);
            addedge(bb,aa);
        }
        tarjan();
        cin>>qu;
        cout<<"Case "<<cas++<<":"<<endl;
        while(qu--)
        {
            scanf("%d%d",&aa,&bb);
            LCA(aa,bb);
            printf("%d\n",cnt-1);
        }
        cout<<endl;
    }
    return 0;
}