pku3694 Network

题意是给出一个连通无向图，求每次加一条边后，图内割边的数目。

最容易想到的方法是每加一条边都做一次DFS求割边，于是code之，提交，TLE。

然后上网搜了一下，看到了一个更直观的方法：设新加入的边为(u,v)，先求u和v的LCA，看从LCA分别到u和v的路径上有多少条割边，然后从原图的割边数目上累减，结果就是所求，因为每加一条边，该边与DFS树上的边形成了环，环内的边就不再是割边了。这样只需要做一次DFS。

 

#include <iostream>
using namespace std;

#define MAXN 100001
#define Min(a,b) (a<b?a:b)

int p[MAXN],ecnt,n,m,q,T=1,lowlink[MAXN],dfn[MAXN],sign,cnt,odeg[MAXN],pnt[MAXN],cutp[MAXN];
bool cut[MAXN],visited[MAXN];

struct Edge{
    int v,next;
}edg[10*MAXN];

void init(){
    ecnt=0;
    memset(p,-1,sizeof(p));
    sign=0;
    memset(dfn,-1,sizeof(dfn));
    memset(odeg,0,sizeof(odeg));
    cnt=0;
    memset(pnt,-1,sizeof(pnt));
    memset(cut,false,sizeof(cut));
    memset(cutp,-1,sizeof(cutp));
}

void dfs(int pre,int u){
    int i,v;
    lowlink[u]=dfn[u]=++sign;
    for(i=p[u];i!=-1;i=edg[i].next){
        v=edg[i].v;
        odeg[u]++;
        if(dfn[v]!=-1){
            if(v!=pre)//
                lowlink[u]=Min(lowlink[u],dfn[v]);
        }
        else{
            dfs(u,v);
            pnt[v]=u;
            lowlink[u]=Min(lowlink[u],lowlink[v]);
            if(dfn[u]<lowlink[v]){
                cnt++;
                cut[u]=true;
                //存割边
                edg[ecnt].next=cutp[u];
                edg[ecnt].v=v;
                cutp[u]=ecnt++;
            }
        }
    }
}



void fun(int u,int v){//找LCA，求LCA分别到u和v的路径上的割边数目，比较暴力
    int t,pt;
    bool find;
    memset(visited,false,sizeof(visited));
    int x=pnt[u],y=pnt[v],LCA=0;
    //找LCA
    while(x!=-1){
        visited[x]=true;
        x=pnt[x];
    }
    while(y!=-1){
        if(visited[y]){
            LCA=y;
            break;
        }
        y=pnt[y];
    }
    if(LCA==0)
        LCA=1;
    x=u,y=v;
    do{
        if(cut[pnt[x]]){//若x的双亲是某一割边的起点，则(pnt[x],x)有可能是一条割边
            find=false;
            pt=t=cutp[pnt[x]];
            while(t!=-1){//看x是不是属于以pnt[x]为起点的割边的终点
                if(edg[t].v==x){
                    find=true;
                    if(pt==t)//找到则从终点集中去掉x
                        cutp[pnt[x]]=edg[t].next;
                    else
                        edg[pt].next=edg[t].next;
                    break;
                }
                pt=t;
                t=edg[t].next;
            }
            if(find)
                cnt--;
            if(cutp[pnt[x]]==-1)//终点集为空，则pnt[x]不再是割边的起点
                cut[pnt[x]]=false;
        }
        x=pnt[x];
    }while(x!=LCA && x!=-1);

    do{
        if(cut[pnt[y]]){
            find=false;
            pt=t=cutp[pnt[y]];
            while(t!=-1){
                if(edg[t].v==y){
                    find=true;
                    if(pt==t)
                        cutp[pnt[y]]=edg[t].next;
                    else
                        edg[pt].next=edg[t].next;
                    break;
                }
                pt=t;
                t=edg[t].next;
            }
            if(find)
                cnt--;
            if(cutp[pnt[y]]==-1)
                cut[pnt[y]]=false;
        }
        y=pnt[y];
    }while(y!=LCA && y!=-1);
}



int main(){
    int i,u,v;
    while(scanf("%d%d",&n,&m) && n && m){
        init();
        for(i=0;i<m;i++){
            scanf("%d%d",&u,&v);
            edg[ecnt].next=p[u];
            edg[ecnt].v=v;
            p[u]=ecnt++;
            edg[ecnt].next=p[v];
            edg[ecnt].v=u;
            p[v]=ecnt++;
        }
        dfs(-1,1);
        scanf("%d",&q);
        printf("Case %d:\n",T++);
        for(i=0;i<q;i++){
            scanf("%d%d",&u,&v);
            fun(u,v);
            printf("%d\n",cnt);
        }
        printf("\n");
    }
    return 0;
}