点双连通分量

点双连通分量定义与性质：

1.     对于点双联通分量，删除任意一点连通性不变，其中不含桥，环与环必定含有公共边，且公共点至少两个，简单圈中的点一定属于同一个点BCC。

 

原理，通过两个标记数组来判别割点，并在dfs过程中用栈来记录每个双联通分量(或是强连通分量)中的点，最后按这些记录缩点建图后是森林。

 

两个标记数组分别是 dfn[] low[]

dfn[]数组记录的是，在dfs树中，某点在dfs过程中此点出现的早晚，越小出现的越早

low[]数组表示此点及其后代能回到的标号（dfn）最小的点，即此点或其后代能回到的最浅的点（dfs树中）。

初始节点需要两个以上儿子且dfn[root]<=low[v] 才是割点

有上述两个数组定义可知：对于某点root，其有一儿子v，则有：

1.     如果dfn[root]<=low[v]此点是割点（对于dfs树的根，即最初节点需要两个儿子才是割点）

2.     如果dfn[root]<low[v]，连接root与v的边是桥。

 

缩点建图

点BCC缩点建图后成森林，原来的点被保留，BCC与BCC之间必定经过割点，割点与割点不会直连（不能用来判桥，因为桥会缩成BCC），除了割点的原来的点只有一条边，且连着其属于的BCC。

 

 

部分代码：

#include<stdio.h>  
#include<string.h>  
#include<iostream>  
#define N 105  
#define M 105*105  
using namespace std;  
struct edge  
{  
    int to,next;  
    edge(){}  
    edge(int to,int next)  
    {  
        this->to=to;  
        this->next=next;  
    }  
}ed[M];  
int head[N],lnum,esum,index,top,bccnum;  
int dfn[N],low[N],mark[M],bj[N],st[M],belong[M],isCut[N];  
pair<int,int>E[M];  
void addline(int from,int to)  
{  
    ed[lnum]=edge(to,head[from]);  
    head[from]=lnum++;  
}  
void tarjan(int root,int fa){//有自环时不加自环的边  
                            //点双连通缩点方法：清空路径，枚举E[]数组中存储的路径，建立双向边。  
    dfn[root]=low[root]=++index; //新点初始化  
    int child=0;   
//初始节点需要两个以上儿子且dfn[root]<=low[v] 才是割点  
    for(int i=head[root];~i;i=ed[i].next){ //遍历root指出去的边  
        int v=ed[i].to;  
        if(mark[i]) continue;   
        mark[i]=mark[i^1]=1;  
        st[++top]=i;//边入栈，需注意此语句要放在判continue之后  
         if(!dfn[v]){ //如果v节点未去过，搜索v节点  
            child++;  
            tarjan(v,root);  
            low[root]=min(low[root],low[v]); //更新low值  
            if(dfn[root]<=low[v]){  
                isCut[root]=1;          //此点是割点，需注意初始节点要有两个儿子  
                bccnum++;//注意这里是N++，建数组时要注意开至少两倍大  
                for(;;){  
                    int j=st[top--];  
            //bj[]数组用来标记节点所属的bcc，割点会改变，无意义  
            //E[]存新图的边，esum是其数量，tarjan结束后建双向边  
                    if(bj[ed[j].to]!=bccnum){  
                        bj[ed[j].to]=bccnum;  
                        E[++esum]=make_pair(ed[j].to,bccnum);  
                    }  
                    if(bj[ed[j^1].to]!=bccnum){  
                        bj[ed[j^1].to]=bccnum;  
                        E[++esum]=make_pair(ed[j^1].to,bccnum);  
                    }  
                    belong[(j>>1)+1]=bccnum;//标记边所属的bcc  
                    if(i==j)break;  
                }  
            }  
        }  
        else low[root]=min(low[root],dfn[v]);   
    //与有向图区分，此处else不需要判别v节点是否在栈内     
 }  
if(root==fa && child<2)isCut[root]=0;   
//如果初始节点没有2个以上儿子，标记清0  
}  
  
void init()  
{  
    memset(head,-1,sizeof(head));  
    memset(dfn,0,sizeof(dfn));  
    memset(low,0,sizeof(low));  
    memset(mark,0,sizeof(mark));  
    memset(belong,0,sizeof(belong));  
    memset(isCut,0,sizeof(isCut));  
	top=0;  
	lnum=0;  
	index=0;  
	bccnum=0;  
	esum=0;  
}