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 100005struct 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; }