hdu - 4338 - Simple Path - 割点 && 双连通

转自冷香： http://blog.sina.com.cn/s/blog_7270d7f901017l3o.html

叙说下题意：就是说给你一些询问，问一个图中，已知s、t，在你已知s、t的情况下，你可能在那些点停留（题目是问你不可能在哪里停留）。

      首先比如说下图： http://acm.hdu.edu.cn/showproblem.php?pid=4338

很简单就是将如图所示的环给缩成点，再随便搞搞就好。

但是再一画，会发现有些情况很麻烦，比如下图：

突然觉得这样很蛋疼，中间那个算那个连通集合呢。。

然后使用双连通分量、割点建图能很有效的解决这个问题。

如上图的建图：

//make_map

拿割点和点双连通建树后:

红色的对应的就是割点，黑色的是点连通分量， 当求(1,7)时候，我们分别查看1,7对应所在树中的集合，求出路径上所有的和 sum = 2 + 1 + 3 + 1 + 3 + 1 + 2 = 13 ，由于割点被重复计算，计算的次数为树边的数量，

len = 6 ， ans = sum - len = 7 ,答案就是可能停留的有7个点。

然后就是如何实现如上问题。

如上图，求1,2的最短距离即为lca（1,2），而结果就是，定义树根到某点路径所有的长度为sson[i],nb[i]为集合中树节点中元素个数

sum = sson[1]+sson[2]-2*sson[3]+nb[3]

len = deep[1]+deep[2]-2*deep[3]

如此，问题转化为求lca的问题了...顺便记录下如上所要用的信息。

代码写了我好久，比较挫。。。

具体见代码：用C++交，不然会栈溢出。

#define sz 100005
struct node
{
    int s,t,nxt;
} e[sz*10];
int hd[sz],cnt;
void insert(int s,int t)
{
    e[cnt].s=s;
    e[cnt].t=t;
    e[cnt].nxt=hd[s];
    hd[s]=cnt++;
}

//   tarjan割点模板，顺便求点连通分量
//   如果stack overflow的话，试试在代码最前面加
//   #pragma comment(linker, "/STACK:102400000,102400000")
int dfn[sz],low[sz],iscut[sz],sta[sz];
int deep,top,bnum,root;
vector <int> block[sz];
void tarjan(int s,int pre)
{
    int flag=0;
    dfn[s]=low[s]=++deep;
    sta[top++]=s;
    for(int i=hd[s]; i!=-1; i=e[i].nxt)
    {
        int t=e[i].t;
        if(t==pre && !flag)//判父边,再次出现为重边,认为连通
        {
            flag=1;
            continue;
        }
        else if(dfn[t]==-1)
        {
            tarjan(t,s);
            low[s]=min(low[s],low[t]);
            if(low[t]>=dfn[s])
            {
                if(pre == -1)root++;
                else iscut[s]=1;
                int tp;
                do
                {
                    tp=sta[--top];
                    block[bnum].pb(tp);
                }
                while(tp!=t);
                block[bnum].pb(s);
                bnum++;
            }
        }
        else
        {
            low[s]=min(low[s],dfn[t]);
        }
    }
}
struct node1
{
    int s,t,v,nxt;
} e1[sz*10];
int hd1[sz],cnt1;
void insert1(int s,int t)
{
    e1[cnt1].s=s;
    e1[cnt1].t=t;
    e1[cnt1].nxt=hd1[s];
    hd1[s]=cnt1++;
}

int lab[sz]; //用于映射
int nb[sz];  //用于记录点中割点数,


int dpmin[sz][20];
int dpminid[sz][20];
int r[sz*2],R[sz*2],lab1[sz*2],sson[sz*2],posid[sz*2];
void create_Dpmin(int n)
{
    for(int i = 1 ; i <= n ; i++ )
    {
        dpmin[i][0] = r[i];
        dpminid[i][0] = i;
    }
    for(int j = 1 ; j <= log((double)(n+1))/log(2.0) ; j++ )
        for(int i = 1 ; i+(1<<j)-1 <= n ; i++ )
            if(dpmin[i][j-1] < dpmin[i+(1<<(j-1))][j-1])
            {
                dpmin[i][j] = dpmin[i][j-1] ;
                dpminid[i][j] = dpminid[i][j-1];
            }
            else
            {
                dpmin[i][j] = dpmin[i+(1<<(j-1))][j-1];
                dpminid[i][j] = dpminid[i+(1<<(j-1))][j-1];
            }
}
int lca(int a,int b)
{
    if(R[a]>R[b])return lca(b,a);
    a=R[a];
    b=R[b];
    int k = (int)(log((double)(b-a+1))/log(2.0));
    return (dpmin[a][k]<dpmin[b-(1<<k)+1][k])?dpminid[a][k]:dpminid[b-(1<<k)+1][k];
}
void dfs(int s,int pos,int pre,int lb,int cnt)
{
    if(R[s]==-1)
    {
        R[s]=deep;
        lab1[s]=lb;
    }
    posid[deep]=s;
    r[deep++]=pos;
    sson[s]=cnt+nb[s];
    for(int i=hd1[s]; i!=-1; i=e1[i].nxt)
    {
        if(e1[i].t == pre)continue;
        dfs(e1[i].t,pos+1,s,lb,sson[s]);
        posid[deep]=s;
        r[deep++]=pos;
    }
}

void solve(int n)
{
    //求割点，求双连通
    rep(i,n)block[i].clear();
    memset(iscut,0,sizeof(iscut));
    memset(dfn,-1,sizeof(dfn));
    deep=top=bnum=0;
    rep(i,n)
        if(dfn[i]==-1)
        {
            root=0;
            tarjan(i,-1);
            iscut[i]=(root>1);
        }
    memset(lab,-1,sizeof(lab));
    int k=0;
    rep(i,n)
        if(iscut[i])
        {
            lab[i]=k;
            nb[k]=1;
            k++;
        }
    memset(hd1,-1,sizeof(hd1));
    cnt1=0;
    rep(i,bnum)
    {
        rep(j,block[i].size())
        {
            int l=block[i][j];
            if(iscut[l])
            {
                insert1(lab[l],k);
                insert1(k,lab[l]);
            }
            else
            {
                lab[l]=k;
            }
        }
        nb[k]=int(block[i].size());
        k++;
    }
    deep=1;
    memset(R,-1,sizeof(R));
    rep(i,k)
        if(R[i]==-1)
            dfs(i,0,-1,i,0);
    create_Dpmin(deep-1);
    int q,s,t,u,v,fa;
    scanf("%d",&q);
    rep(i,q)
    {
        scanf("%d%d",&s,&t);
        if(s == t) //相同
        {
            printf("%d\n",n-1);
            continue;
        }
        if(lab[s]==-1 || lab[t]==-1) // lab为-1时候，表示孤立的点，既不是割点也不是块
        {
            printf("%d\n",n);
            continue;
        }
        u = lab[s]; //对应映射过去的点
        v = lab[t];

        if(lab1[u]!=lab1[v]) // 对块形成的树进行连通判断,不在同集合
        {
            printf("%d\n",n);
            continue;
        }
        fa = lca(u,v); // 返回dfs后lca的对应在r串所在位置,r串是lca要用到的深度
        fa = posid[fa];// posid对应的是r串对应的节点
        int len;
        len = r[R[u]]+r[R[v]]-2*r[R[fa]]; //路径长度
        int ans;
        ans = sson[u]+sson[v]-2*sson[fa]+nb[fa];
        ans -= len;
        printf("%d\n",n-ans);
    }
}

int main()
{
    int n,m,s,t;
    int cas=1;
    while(~scanf("%d%d",&n,&m))
    {
        memset(hd,-1,sizeof(hd));
        cnt=0;
        rep(i,m)
        {
            scanf("%d%d",&s,&t);
            insert(s,t);
            insert(t,s);
        }
        printf("Case #%d:\n",cas++);
        solve(n);
        printf("\n");
    }
}

　题目大意是说给你一个起点和终点，一个人要从起点走到终点，它不能经过一个点两次，问他不可能经过哪些点。

　　显然转化成能经过哪些点要好想一些，用N减去能经过的点就可以得到答案。下面的讨论都是基于求他可能经过的点有多少个。

　　很容易想到用双联通分量，但是建图确实比较麻烦。如下图，一个人想要从1走到3，那它可能在的点就是1，2，3。因为2是一个割点，它如果从2走到了4，想要到达3就必须再经过2，所以可以用割点和双联通建图。

　　用割点和双联通可以建成双联通与割点相邻的图，若右图所示。可以证明这是一棵树，因为如果存在环，这个环必然可以缩成一个点，树中任意两点有且仅有一条路径，于是只要统计这条路径上有一共多少个点即可。但是有一个问题就是割点会被重复统计，每一个割点会被它左边以及右边的双连通分量各多统计一次，因此只要将点数减去路径上的边数即可，例如求1-3，答案就是2+1+2-2=3。

 

　　

　　

　　     

　　快速计算路径上的点数总和要用到LCA，先DP处理出每个节点到根节点的距离dis[u]，以及到根节点的节点总数Tsum[u]，每个节点的包含的节点数记为sum[u]，则这条路径上的点数为ans=(Tsum[u]+Tsum[v]-2*Tsum[lca(u,v)]+sum[lca(u,v)])-(dis[u]+dis[v]-2*dis[lca(u,v)])。LCA可以转化成RMQ以便在线查询，每次查询复杂度logN。

　　还要注意几个小问题，在建树的时候用并查集进行合并，这样就可以快速判断两个点是否在同一个连通分量中；另外在可以虚拟一个父亲节点，到所有的连通块中各连一条边，这样可以使dp方便很多。查询时，对点进行映射，如果这个点是割点，一定要将其映射到割点所对应的节点，因为割点在tarjan中是会被染成不同的颜色的。

　　有几个小trick，起点与终点可能不联通，也可能在同一个点，需要特判。

　　比较坑的是DP会爆栈，但是不用DP将LCA转RMQ会比较麻烦，只能手动扩栈(加上第一行)，然后用C++交了。

#pragma comment(linker, "/STACK:102400000,102400000")
 #include <string.h>
 #include <stdio.h>
 #include <math.h>
 #include <algorithm>
 #define MAXN 100005
 struct edge{
     int u,v,n;
 }e1[MAXN*4],e2[MAXN*4];
 int f1[MAXN],f2[MAXN*2],es1,es2;
 int n,m,q,tu,tv;
 void addedge1(int u,int v){
     e1[es1].u=u,e1[es1].v=v,e1[es1].n=f1[u],f1[u]=es1++;
 }
 void addedge2(int u,int v){
     e2[es2].u=u,e2[es2].v=v,e2[es2].n=f2[u],f2[u]=es2++;
 }
 //===并查集===
 int p[MAXN*2];
 int find(int x){return x==p[x]?x:p[x]=find(p[x]);}
 void merge(int x,int y){p[find(x)]=find(y);}
 //===DP&RMQ===
 int sum[MAXN*2],tsum[MAXN*2],dis[MAXN];
 int lca_f[MAXN*4],lca_b[MAXN*4],lca_p[MAXN*2],rid;
 int dminv[MAXN*4][20],dminid[MAXN*4][20];
 void dp(int u,int f,int dd,int tot){
    // printf("%d :%d %d\n",u,dd,sum[u]);
     dis[u]=dd,tsum[u]=tot+sum[u];
     lca_f[++rid]=u,lca_b[rid]=dd,lca_p[u]=rid;
     for(int i=f2[u];i!=-1;i=e2[i].n){
         int v=e2[i].v;
         if(v==f)continue;
         dp(v,u,dd+1,tot+sum[u]);
         lca_f[++rid]=u,lca_b[rid]=dd;
     }
 }
 void makermq(){
     rid=0;
     dp(0,-1,0,0);
     for(int i=1;i<=rid;i++)dminv[i][0]=lca_b[i],dminid[i][0]=i;
     int maxj=(int)(log(rid+1.0)/log(2.0));
     for(int j=1;j<=maxj;j++){
         int maxi=rid+1-(1<<j);
         for(int i=1;i<=maxi;i++){
             if(dminv[i][j-1]<dminv[i+(1<<(j-1))][j-1]){
                 dminv[i][j]=dminv[i][j-1];
                 dminid[i][j]=dminid[i][j-1];
             }else{
                 dminv[i][j]=dminv[i+(1<<(j-1))][j-1];
                 dminid[i][j]=dminid[i+(1<<(j-1))][j-1];
             }
         }
     }
 }
 int lca(int x,int y){
     if(lca_p[x]>lca_p[y])std::swap(x,y);
     x=lca_p[x],y=lca_p[y];
     int k=(int)(log(y-x+1.0)/log(2.0));
     int xx=dminv[x][k]<dminv[y+1-(1<<k)][k]?dminid[x][k]:dminid[y+1-(1<<k)][k];
     return lca_f[xx];
 }
 //===Tarjan===
 int dfn[MAXN],low[MAXN],cid[MAXN],stk[MAXN],col[MAXN],top,ind,cls,tmp;
 int cal[MAXN*2];
 //为割点的条件是根节点能搜到两个分支或者low[v]>=dfn[u],找到割点并给割点标号
 void dfs_cutpnt(int u,int f,int root){
     dfn[u]=low[u]=++ind;
     int cnt=0;
     int flag=0;
     for(int i=f1[u];i!=-1;i=e1[i].n){
         int v=e1[i].v;
         if(v==f&&!flag){flag=1;continue;}
         if(!dfn[v]){
             cnt++;
             dfs_cutpnt(v,u,root);
             if(low[v]<low[u])low[u]=low[v];
             if(u==root&&cnt>1&&cid[u]==0)cid[u]=++cls,sum[cls]=1;
             else if(u!=root&&low[v]>=dfn[u]&&cid[u]==0)cid[u]=++cls,sum[cls]=1;
         }else if(dfn[v]<low[u])low[u]=dfn[v];
     }
 }
 //找双联通分量并给双联通分量标号,当这个双联通分量中包含某个割点时,连一条边
 void dfs_tarjan(int u,int f){
     low[u]=dfn[u]=++ind;
     stk[++top]=u;
     int flag=0;
     for(int i=f1[u];i!=-1;i=e1[i].n){
         int v=e1[i].v;
         if(v==f&&!flag){flag=1;continue;}
         if(!dfn[v]){
             dfs_tarjan(v,u);
             if(low[v]<low[u])low[u]=low[v];
             if(low[v]>=dfn[u]){
                 sum[++cls]=1,col[u]=cls;
                 do{
                     tmp=stk[top--],col[tmp]=cls,++sum[cls];
                     if(cid[tmp]){addedge2(cid[tmp],cls);addedge2(cls,cid[tmp]);merge(cid[tmp],cls);}
                 }while(tmp!=v);
                 if(cid[u]){addedge2(cid[u],cls);addedge2(cls,cid[u]);merge(cid[u],cls);}
             }
         }else if(dfn[v]<low[u])low[u]=dfn[v];
     }
 }
 int size;
 void makegraph(){
     //找割点
     memset(dfn,0,sizeof dfn);
     memset(low,0,sizeof low);
     memset(cid,0,sizeof cid);
     cls=ind=0;
     //找双联通分量并建图
     for(int i=0;i<n;i++)dfs_cutpnt(i,-1,i);
     memset(dfn,0,sizeof dfn);
     memset(low,0,sizeof low);
     memset(col,0,sizeof col);
     top=ind=0;
     for(int i=0;i<n;i++)dfs_tarjan(i,-1);
     //将森林补成树,便于dp以及查询
     memset(cal,0,sizeof cal);
     for(int i=1;i<=cls;i++){
         if(cal[find(i)]==0){
             cal[find(i)]=1;
             addedge2(0,i);
         }
     }
 }
 int main(){
     //freopen("test.in","r",stdin);
     int cas=1;
     while(scanf("%d%d",&n,&m)!=EOF){
         memset(f1,-1,sizeof f1);
         memset(f2,-1,sizeof f2);
         for(int i=0;i<=2*n;i++)p[i]=i;
         es1=es2=0;
 
         for(int i=0;i<m;i++){
             scanf("%d%d",&tu,&tv);
             addedge1(tu,tv);
             addedge1(tv,tu);
         }
 
         //转化成双联通与割点相邻的图
         makegraph();
         //lca转化成rmq
         makermq();
 
         printf("Case #%d:\n",cas++);
         scanf("%d",&q);
         while(q--){
             scanf("%d%d",&tu,&tv);
             //起点和终点重合
             if(tu==tv)printf("%d\n",n-1);
             else{
                 //如果是割点的话就一定要用割点对应的点,因为割点会被染成不同的颜色!
                 tu=cid[tu]?cid[tu]:col[tu];
                 tv=cid[tv]?cid[tv]:col[tv];
                 //孤立点或者不在同一个联通块中
                 if(tu==0||tv==0||find(tu)!=find(tv)){
                     printf("%d\n",n);
                 }else{
                     int fa=lca(tu,tv);
                     int ans=tsum[tu]+tsum[tv]-2*tsum[fa]+sum[fa];
                     ans-=(dis[tu]+dis[tv]-2*dis[fa]);
                     printf("%d\n",n-ans);
                 }
             }
         }
         printf("\n");
     }
     return 0;
 }