下面介绍中无向图中割点和桥的概念：
割点：一个结点称为割点（或者割顶）当且仅当去掉该节点极其相关的边之后的子图不连通。
桥：一条边称为桥（或者割边）当且仅当去掉该边之后的子图不连通。
首先我们考虑一个连通图（非连通图可以分别考虑连通块），我们从任意一个起点开始进行深度优先搜索，可以得到一棵树，并且这棵树中所有结点的子树之间不存在边，即没有跨越两棵子树的边（考虑一下，如果存在，那么与深度优先搜索树的定义互相矛盾）。于是有如下定理：
在无向连通图G中，
1、根结点u为割顶当且仅当它有两个或者多个子结点；
2、非根结点u为割顶当且仅当u存在子结点v，使得v极其所有后代都没有反向边可以连回u的祖先（连回u不算）
在Tarjan算法里面，有两个时间戳非常重要，一个是dfn，意为深度优先数，即代表访问顺序；一个是low，意为通过反向边能到达的最小dfn。于是，上述定理中第二个条件（非根结点）可以简单地写成low[v]>=dfn[u]。

Network
割点

#include <cstdio>
#include<cstring>
#include<vector>
using namespace std;
const int MAXN=110;
vector<int> graph[MAXN];
int dfn[MAXN];
int low[MAXN];
int dfn_clock;
int isCut[MAXN];
int tarjan(int u,int fa)
{
    int lowu=dfn[u]=++dfn_clock;
    int child=0;
    for(int i=0;i<graph[u].size();i++)
    {
        int v=graph[u][i];
        if(dfn[v]==0)
        {
            child++;
            int lowv=tarjan(v,u);
            lowu=min(lowv,lowu);
            if(lowv>=dfn[u])
            {
                isCut[u]=1;
            }
        }
        else if(dfn[u]>dfn[v]&&v!=fa)
        {
            lowu=min(dfn[v],lowu);
        }
    }
    if(fa<0&&child==1) isCut[u]=0;
    low[u]=lowu;
    return lowu;
}
int main()
{
    int n;
    int u,v;
    char c;
    while(scanf("%d",&n)!=EOF&&n)
    {
        memset(graph,0,sizeof(graph));
        dfn_clock=0;
        while(true)
        {
            scanf("%d",&u);
            if(u==0) break;
            getchar();
            while(true)
            {
                scanf("%d",&v);
                graph[u].push_back(v);
                graph[v].push_back(u);
                c=getchar();
                if(c=='\n') break;
            }
        }
        memset(dfn,0,sizeof(dfn));
        memset(isCut,0,sizeof(isCut));
        tarjan(1,-1);
        int sum=0;
        for(int i=1;i<=n;i++)
        {
            if(isCut[i]) sum++;
        }
        printf("%d\n",sum);
    }
    return 0;
}

桥:
桥的求法其实也是类似的，它的求法可以看成是割顶的一种特殊情况，当结点u的子结点v的后代通过反向边只能连回v，那么删除这条边(u, v)就可以使得图G非连通了。用Tarjan算法里面的时间戳表示这个条件，就是low[v]>dfn[u]。

int n,stamp,dfn[1005],low[1005];
int cnt,ansx[10005],ansy[10005];
vector<int> vec[1005];
int rank[1005];
void addAns(int x,int y)
{
    if(x>y)
        swap(x,y);
    ansx[cnt]=x, ansy[cnt]=y;
    cnt++;
}
void tarjan(int index,int fa)
{
    int tmp;
    dfn[index]=low[index]=++stamp;
    for(int i=0;i<vec[index].size();i++)
    {
        tmp=vec[index][i];
        if(!dfn[tmp])
        {
            tarjan(tmp,index);
            low[index]=min(low[index],low[tmp]);
            if(low[tmp]>dfn[index])
                addAns(index,tmp);
        }
        else if(dfn[tmp]<dfn[index] && tmp!=fa)
        {
            low[index]=min(low[index],dfn[tmp]);
        }
    }
}