点/边 双连通分量---Tarjan算法

       运用Tarjan算法，求解图的点/边双连通分量。

1、点双连通分量【块】

      割点可以存在多个块中，每个块包含当前节点u，分量以边的形式输出比较有意义。

typedef struct{  //栈结点结构  保存边
	int front;
	int rear;
}BNode;
BNode block_edge[MAXL];                                                                                                                                  

int top;  //栈指针,指向下一个空位
int num_block; //块计数
int b1,b2;  //存储块中的边  辅助信息[全局变量]

void add(int *top,int front,int rear)  //边入栈
{
	if(*top < MAXL)
	{
		block_edge[*top].front=front;
		block_edge[*top].rear=rear;
		(*top)++;
	}
}
void del(int *top)  //边出栈
{
	if(*top > 0)
	{
		(*top)--;
		b1=block_edge[*top].front;
		b2=block_edge[*top].rear;
	}
}

void init_dfnlow(void)  //初始化
{
	depth=0;
	root=0;  //【**可自定义**】若不输出割点，可以不用
	num_block=0;
	for(int i=0;i<ALG->n;i++)
	{
		vis[i]=0;
		dfn[i]=low[i]=-1;
	}

	top=0;
	b1=b2=-1;
	for(int j=0;j<ALG->e;j++)
	{
		block_edge[j].front=0;
		block_edge[j].rear =0;
	}
}

void cutblock_Tarjan(int u,int parent)
{
	int son;
	ENode *ptr=(ENode *)malloc(sizeof(ENode));

	dfn[u]=low[u]=depth++;
	vis[u]=1;
	ptr=ALG->vlist[u].firstedge;
	while(ptr!=NULL)
	{
		son=ptr->key;
		if(son!=parent && dfn[son]<dfn[u]) //非树边&&回退边
		{                                // 新边压栈,v!=w是防止重复计算无向图中同一条树边
                 add(&top,u,son);           //dfn[w]<dfn[u] 是防止重复计算回退边
			 if(!vis[son])
			 {
				 cutblock_Tarjan(son,u);
				 low[u]=MIN(low[u],low[son]);
				 if(low[son] >= dfn[u])  //u是割点,输出连通分支，包括(u,son)
				 {
					 num_block++;
					 do{
						del(&top);
						printf("<%c,%c> ",ALG->vlist[b1].vertex,ALG->vlist[b2].vertex);
					 }while(!(u==b1 && son==b2));
					 printf("\n");

					/* del(&top);   //两种不同的输出形式
					 while(!((u==b1) && (son==b2)))
					 {
						printf("<%c,%c>,",ALG->vlist[b1].vertex,ALG->vlist[b2].vertex);
					        del(&top);
					 }
					 printf("<%c,%c>\n",ALG->vlist[u].vertex,ALG->vlist[son].vertex);  */
				 }
			 }
			 else if(son != parent)
			 {
				low[u]=MIN(low[u],dfn[son]);
			 }
		}
		
		ptr=ptr->next;
	}
}

2、边双连通分量【缩点】

     某一个点只能在一个“缩点”内，“缩点”时不包括当前节点u，分量以顶点的形式输出。

int stack[MAXL];  //栈用于缓存缩点,存放编号
int top;  
int bnode[MAXL];  //用于存储缩点，存放编号
int count_bnodeele; //分量元素计数

void init_Tarjan(void)
{
	depth=0;
	num_bridge=0;
	for(int i=0;i<ALG->n;i++)
	{
		dfn[i]=low[i]=-1;
		vis[i]=0;
	//	bridge[i]=0;
		stack[i]=-1;
	}
	top=0;
}

void init_bnode(void) //缩点初始化
{
	count_bnodeele=0;
	for(int i=0;i<ALG->n;i++)
		bnode[i]=-1;
}

void bridge_node_Tarjan(int u,int parent)
{
	int son;
	ENode *ptr=(ENode*)malloc(sizeof(ENode));

	dfn[u]=low[u]=depth++;  //访问+标记+入栈+遍历
	vis[u]=1;
	stack[top++]=u;
	ptr=ALG->vlist[u].firstedge;
	while(ptr!=NULL)
	{
		son=ptr->key;
		if(son!=parent && dfn[son]<dfn[u])
		{
			if(!vis[son])
			{
				bridge_node_Tarjan(son,u);
				low[u]=MIN(low[u],low[son]);
				if(low[son] > dfn[u])  //(u,son)是桥
				{
					num_bridge++;
					init_bnode(); //缩点初始化
					while(stack[--top] != son)
					{
						bnode[count_bnodeele++]=stack[top];
					}
					bnode[count_bnodeele]=stack[top];

					for(int cn=0;cn<=count_bnodeele;cn++) //缩点输出
						printf("%c ",ALG->vlist[bnode[cn]].vertex);
					printf("\n");
				}
			}
			else if(son != parent)
			{
				low[u]=MIN(low[u],dfn[son]);
			}
		}
		ptr=ptr->next;
	}
}

	while(top != 0) //最后节点无法全部出栈,被自然分成一个连通分量【***此步必须要有***】
	{
		top--;
		printf("%c ",ALG->vlist[stack[top]].vertex);
	}
	printf("\n");