割点、割边

定义：

无向图中，删除某个点(集)之后图不连通，该点即为割点(集)；

无向图中，删除某个边(集)之后图不连通，该点即为割边(集)。

 

算法：

dfs过程中，如果某个子树完全不与访问过的祖先节点相连，则

该子树根以及连接根与父亲节点的边则为割点以及割边。  于是

 

割点： 某个儿子节点层号>=父亲节点层号（父亲节点） or  有多个儿子的根节点

割边： 某个儿子节点层号>父亲节点层号（父亲节点与儿子节点的边）

 伪代码：

void DFS(int father)
{
        dep[father] = depth;
        low[father] = depth;
        vis[father] = true;
        depth ++;


        for each son of father{
                if(!vis[son]){
                        DFS(son);
                        low[father] = min(low[father],low[son]);
                        if(low[son] >= dep[father] 
                            && father is not root)  // point      
                        // if(low[son]>dep[father]) // edge
                        if(father==root) root_son_num ++;
                }
                low[father] = min(low[father],dep[son]);
        }
}

 

poj1144:

#include <cstdio>
#include <cstring>

const int N=111, M=N*N;

int hed[N], nex[M], to[M], ind, n;
int dep[N], low[N], vip[N], yes[N], depth, nr, r=1;

inline void ins(int u, int v)
{
	++ind; to[ind]=v; nex[ind]=hed[u]; hed[u]=ind;
	++ind; to[ind]=u; nex[ind]=hed[v]; hed[v]=ind;
}

inline int min(int a, int b)
{
	return a<b?a:b;
}

void input()
{
	memset(hed, 0, sizeof(hed));
	memset(nex, 0, sizeof(nex));
	ind=1;

	int u, v;
	while(~scanf("%d", &u) && u)
	{
		while(getchar()!='\n')
		{
			scanf("%d", &v);
			ins(u, v);
		}
	}
}

void dfs(int f)
{
	dep[f]=low[f]=++depth;
	vip[f]=1;

	int s, x;
	for(x=hed[f]; x; x=nex[x])
	{
		s=to[x];
		if(!vip[s])
		{
			dfs(s);
			low[f]=min(low[f], low[s]);
			if(low[s]>=dep[f]) yes[f]=1;
			if(f==r) nr++;
		}
		low[f]=min(low[f], dep[s]);
	}
}

void work()
{
	depth=nr=0;
	memset(vip, 0, sizeof(vip));
	memset(yes, 0, sizeof(yes));

	dfs(r);

	int i, ans=0;
	if(nr>=2) ans++;
	for(i=2; i<=n; ++i) ans+=yes[i];
	printf("%d\n", ans);
}

int main()
{
	while(~scanf("%d", &n) && n)
	{
		input();
		work();
	}
	return 0;
}

练习：poj 3177 3352 1999 3694 1815

for more：http://www.byvoid.com/blog/biconnect/