POJ 1523 SPF 无向图求割点和块

来源：http://poj.org/problem?id=1523

题意：给一个无向图，求该无向图中的割点和该割点属于块的数量。一个割点是可以属于多个块的。

思路：深搜，dfs解决。给出一些无向图中关于割点割边的知识，是从网上找的。

一、基本概念

无向图

割点：删掉它之后(删掉所有跟它相连的边)，图必然会分裂成两个或两个以上的子图。

块：没有割点的连通子图

割边：删掉一条边后，图必然会分裂成两个或两个以上的子图，又称桥。

缩点：把没有割边的连通子图缩为一个点，此时满足任意两点间都有两条路径相互可达。

求块跟求缩点非常相似，很容易搞混，但本质上完全不同。割点可以存在多个块中(假如存在k个块中)，最终该点与其他点形成k个块，对无割边的连通子图进行缩点后(假设为k个)，新图便变为一棵k个点由k-1条割边连接成的树，倘若其中有一条边不是割边，则它必可与其他割边形成一个环，而能继续进行缩点。

有割点的图不一定有割边，如：               有割边的图也不定有割点,如：                       

3是割点，分别与(1,2)和(4,5)形成两个无割点的块         w(1,2)为割边，

有向图

强连通分量：有向图中任意两点相互可达的连通子图，其实也十分类似于无向图中的缩点

二、算法

无向图

借助两个辅助数组dfn[],low[]进行DFS便可找到无向图的割点和割边，用一个栈st[]维护记录块和“缩点”后连通子图中所有的点。

dfn[i]表示DFS过程中到达点i的时间，low[i]表示能通过其他边回到其祖先的最早时间。low[i]=min(low[i],dfn[son[i]])

设 v,u之间有边w(v,u)，从v->u：

   如果low[u]>=dfn[v],说明v的儿子u不能通过其他边到达v的祖先，此时如果拿掉v,则必定把v的祖先和v的儿子u，及它的子孙分开，于是v便是一个割点，v和它的子孙形成一个块。

    如果low[u]>dfn[v]时，则说明u不仅不能到达v的祖先，连v也不能通过另外一条边直接到达，从而它们之间的边w(v,u)便是割边，求割边的时候有一个重边的问题要视情况处理，如果v,u之间有两条无向边，需要仍视为割边的话，则在DFS的时候加一个变量记录它的父亲,下一步遇到父结点时不扩展回去，从而第二条无向重边不会被遍历而导致low[u]==dfn[v] ,而在另外一些问题中，比如电线连接两台设备A,B 如果它们之间有两根电线，则应该视为是双连通的，因为任何一条电线出问题都不会破坏A和B之间的连通性，这个时候，我们可以用一个used[]数组标记边的id,DFS时会把一条无向边拆成两条有向边进行遍历,但我们给它们俩同一个id号，在开始遍历v->u前检查它的id是否在上一次u->v时被标记，这样如果两点之间有多条边时，每次遍历都只标记其中一条，还可以通过其他边回去，形成第二条新的路

   求割点的时候，维护一个栈st 每遍历到一个顶点v则把它放进去，对它的子孙u如果dfn[u]为0，则表示还没有遍历到则先DFS(u),之后再判断low[u]和dfn[v]，如果low[u]>=dfn[v],则把栈中从栈顶到v这一系列元素弹出，这些点与v形成一个块，如果u的子孙x也是一个割点，这样做会不会错把它们和v，u放在一起形成一个块呢，这种情况是不会发生的，如果发现x是一个割点，则DFS到x那一步后栈早就把属于x的子孙弹出来了，而只剩下v,u的子孙，它们之间不存在割点，否则在回溯到v之前也早就提前出栈了！画一个图照着代码模拟一下可以方便理解。

   求割边也是一样的。

有向图

有向图强连通分量的算法有两个，一个是Kosaraju,另一个是Tarjan，前者需要两次DFS，代码量偏大但容易理解，后者只需要一次DFS和维护一个栈便可以，实现简单，详见这里>>

三、代码实现

割点和块

求割点的时候由于不知道最开始选的树根是不是只有一个儿子，这样在DFS过来中不会满足low[u]>=dfn[v]而判为割点，但有两个或两个以上儿子的根肯定也是一个割点，所以要特判！

void CutBlock(int v){
    dfn[v]=low[v]=++cnt;
    st[++top]=v;
    for(int i=p[v];i!=-1;i=edge[i].pre){
        int u(edge[i].d);
        if(dfn[u]==0){
            CutBlock(u);
            GetMin(low[v],low[u]);
            if(low[u]>=dfn[v]){ //V是一个割点
                block[0]=0;
                while (true) {
                    block[++block[0]]=st[top];
                    if (st[top--] == u) //只能弹到u为止，v还可以在其他块中
                        break; 
                }
                block[++block[0]]=v;//割点属于多个块，一定要补进去
                Count(block);
            }
        }
        else GetMin(low[v],dfn[u]);
    }
}

割边和缩点

void CutEdge(int v,int fa){
    dfn[v]=low[v]=++cnt;
    st[++top]=v;
    for(int i=p[v];i!=-1;i=edge[i].pre){
        int u(edge[i].d);
        if(u==fa)continue;
        if(!dfn[u]){
            CutEdge(u,v);
            GetMin(low[v],low[u]);
            if(low[u]>dfn[v]){//边v->u为一条割边
                cutE[++numE]=E(v,u);
                // 将u及与它形成的连通分量的所有点存起来
                ++numB;
                while(1){
                    id[st[top]]=numB;
                    if(st[top--]==u)break;
                }
            }
        }
        else GetMin(low[v],dfn[u]);
    }
}

有向图强连通分量

void Tarjan(int v){
    dfn[v]=low[v]=++num;
    used[v]=1; 
    st[++numSt]=v;
    for(int i=p[v];i!=-1;i=edge[i].pre){
        int u(edge[i].d);
        if(!dfn[u])//还没有标号的点
        {
            Tarjan(u);//先遍历它的子结点
            GetMin(low[v],low[u]);//用子结点更新当前点的low值
        }
        else if(used[u]&&GetMin(low[v],dfn[u])); 
    }
    if(dfn[v]==low[v]){
        scc++;
        while(1){ 
            int u(st[numSt--]); 
            id[u]=scc;
            used[u]=0;
            if(v==u)break;
        }
    }
}

该题代码：

//1523
#include <iostream>
#include <cstdio>
#include <vector>
#include <string.h>
using namespace std;

#define CLR(arr,val) memset(arr,val,sizeof(arr))
const int N = 1010;
int low[N],dfn[N],head[N],numblock[N],vis[N];
vector<int> vv[N];
int timeorder,numpoint = 0,numson;
void init(){
	CLR(low,0);
	CLR(dfn,0);
	CLR(head,-1);
	CLR(numblock,0);
	CLR(vv,0);
	CLR(vis,0);
	timeorder = 0;
	numson = 0;
}
int max(int a,int b){
	return a > b ? a : b;
}
int min(int a,int b){
	return a < b ? a : b;
}
void dfs(int x){
	timeorder++;
	low[x] = dfn[x] = timeorder;
	vis[x] = 1;
	for(int i = 0; i < vv[x].size(); ++i){
	  int y = vv[x][i];
	  if(!vis[y]){
	    dfs(y);
		low[x] = min(low[x],low[y]);
		if(low[y] >= dfn[x] && x != 1)
			numblock[x]++;
		else if( x == 1 )
			numson++;
	  }
	  else
		  low[x] = min(low[x],dfn[y]);
	}
}
int main(){
	//freopen("1.txt","r",stdin);
	int lp1,numcase = 0,ca = 0;
	while(scanf("%d",&lp1) && lp1){
		init();
		numpoint = max(numpoint,lp1);
	  int rp1;
	  scanf("%d",&rp1);
	  numpoint = max(numpoint,rp1);
	  vv[lp1].push_back(rp1);
	  vv[rp1].push_back(lp1);
	  int lp,rp;
	  while(1){
		  scanf("%d",&lp);
		  if(lp == 0)
			  break;
		  numpoint = max(numpoint,lp);
	     scanf("%d",&rp);
		 numpoint = max(numpoint,rp);
		 vv[lp].push_back(rp);
		 vv[rp].push_back(lp);
	  }
	  if(ca) printf("\n");
	  ca++;
      dfs(1);
	  printf("Network #%d\n",++numcase);
	  bool flag = false;
	  if(numson > 1){
	    flag = true;
		printf("  SPF node 1 leaves %d subnets\n",numson);
	  }
	  for(int i = 1; i <= numpoint; ++i){
	    if(numblock[i]){
			flag = true;
			printf("  SPF node %d leaves %d subnets\n",i,numblock[i]+1);
		}
	  }
	  if(!flag)
		  printf("  No SPF nodes\n");
	}
	return 0;
}

转载于:https://www.cnblogs.com/javaspring/archive/2012/08/21/2656263.html