割点，桥，双连通分量Tarjan ，入门练习

POJ 2117
求在一个无向图中，删去一个点，图中最多的连通块有多少个。
因为是无向图，初识的连通块block在，dfs里面就可以找到，然后我们只要找到割点，记录增加的连通块数目，最后扫一遍 取最大值就好了！
Wa的原因：初识化的ans 应该是初识连通块-1，我没读题，看样例做的，所以没怎么注意

#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <sstream>
#include <queue>
#include <typeinfo>
#include <fstream>
#include <map>
#include <stack>
typedef long long ll;
using namespace std;

const int MAXN = 100010;//点数
const int MAXM = 1000010;//边数，因为是无向图，所以这个值要*2

struct Edge
{
    int to,next;
    bool cut;//是否是桥标记
    bool cong;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];//  Belong数组表示属于哪一个连通块
int Index,top;
bool Instack[MAXN];
bool cut[MAXN];    //自然用来存割点
int add_block[MAXN];  // 删除一个点后增加的连通块数
int bridge;//桥的数目
int block; // 连通块数量
void addedge(int u,int v)
{
    edge[tot].to = v;edge[tot].next = head[u];edge[tot].cut=false;
    head[u] = tot++;
}

void Tarjan(int u,int pre)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    int son=0;    //  统计某个点在搜索树中的儿子个数
    for(int i = head[u];i != -1;i = edge[i].next)
    {
        v = edge[i].to;
        if(v == pre )continue;
        if( !DFN[v] )
        {
            son++;
            Tarjan(v,u);
            if( Low[u] > Low[v] )  Low[u] = Low[v];

            //一条边 (u,v)是桥，当且仅当(u,v)为树枝边(u,v都在栈里面),且满足DFN(u)<Low(v)
            if(Low[v] > DFN[u])
            {
                bridge++;
                edge[i].cut = true;
                edge[i^1].cut = true;   //因为是无向图，自然增加了两条边
            }
            //割点
            //一个顶点u是割点，当且仅当满足（1）或者(2);  （1）u为树根,且u有多于一个子树。
            //（2）u不为树根，且满足存在(u,v)为树枝边（u为v在搜索树中的父亲），使DFS(u)<=Low(v)
            if(u!=pre && Low[v] >= DFN[u]){
                 cut[u] =true;
                 add_block[u]++;
            }
        }
        else if( Instack[v] && Low[u] > DFN[v] )
            Low[u] = DFN[v];
    }
    //数根，分支数>1
    if(u== pre && son>1 )  cut[u]=true;
    if(u== pre)  add_block[u]=son-1;
    Instack[u]=false;
    top--;
}
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}
void solve(int N){
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    memset(add_block,0,sizeof(add_block) );
    memset(cut,false,sizeof(cut) );
    Index=top=block=0;
    for(int i=1;i<=N;i++)
        if(!DFN[i]){
           block++;
           Tarjan(i,i);
        }
}
int main(){
    int p,c;
    //freopen("1.txt","r",stdin);
    while(~scanf("%d %d",&p,&c) &&( p||c)){
        init();
        for(int i=0;i<c;i++){
            int u,v;
            scanf("%d %d",&u,&v);
            u++,v++;
            addedge(u,v);
            addedge(v,u);
        }
        solve(p);
        int ans=block-1;
        for(int i=1;i<=p;i++){
//          printf("add=%d ",add_block[i]);
            ans=max(ans,block+add_block[i]);
        }
        printf("%d\n",ans);
    }
    return 0;
}

Uva 796
题意：给一个无向图，按所连点的编号从小到大输出所有桥
Sample Input
8
0 (1) 1
1 (3) 2 0 3
2 (2) 1 3
3 (3) 1 2 4
4 (1) 3
7 (1) 6
6 (1) 7
5 (0)

0
Sample Output

3 critical links
0 - 1
3 - 4
6 - 7

0 critical links

这也是一个模板题吧，直接找出桥，然后从小到大输出即可

/*
 求无向图的割点和桥
 可以找出 割点和桥，求出删掉每个点后增加的连通块
 需要注意重边的处理，可以先用矩阵存，再转领接表，或者判重
 */
#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <sstream>
#include <queue>
#include <typeinfo>
#include <fstream>
#include <map>
#include <stack>
typedef long long ll;
using namespace std;

const int MAXN = 100010;//点数
const int MAXM = 1000010;//边数，因为是无向图，所以这个值要*2

struct Edge
{
    int to,next;
    bool cut;//是否是桥标记
    bool cong;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];//  Belong数组表示属于哪一个连通块
int Index,top;
bool Instack[MAXN];
bool cut[MAXN];    //自然用来存割点
int add_block[MAXN];  // 删除一个点后增加的连通块数
int bridge;//桥的数目
int block; // 连通块数量

int uu[MAXN];
void addedge(int u,int v)
{
    edge[tot].to = v;edge[tot].next = head[u];edge[tot].cut=false;uu[tot]=u;
    head[u] = tot++;
}

void Tarjan(int u,int pre)
{
    int v;
    Low[u] = DFN[u] = ++Index;
    Stack[top++] = u;
    Instack[u] = true;
    int son=0;    //  统计某个点在搜索树中的儿子个数
    for(int i = head[u];i != -1;i = edge[i].next)
    {
        v = edge[i].to;
        if(v == pre )continue;
        if( !DFN[v] )
        {
            son++;
            Tarjan(v,u);
            if( Low[u] > Low[v] )  Low[u] = Low[v];

            //一条边 (u,v)是桥，当且仅当(u,v)为树枝边(u,v都在栈里面),且满足DFN(u)<Low(v)
            if(Low[v] > DFN[u])
            {
                bridge++;
                edge[i].cut = true;
                edge[i^1].cut = true;   //因为是无向图，自然增加了两条边
            }
            //割点
            //一个顶点u是割点，当且仅当满足（1）或者(2);  （1）u为树根,且u有多于一个子树。
            //（2）u不为树根，且满足存在(u,v)为树枝边（u为v在搜索树中的父亲），使DFS(u)<=Low(v)
            if(u!=pre && Low[v] >= DFN[u]){
                 cut[u] =true;
                 add_block[u]++;
            }
        }
        else if( Instack[v] && Low[u] > DFN[v] )
            Low[u] = DFN[v];
    }
    //数根，分支数>1
    if(u== pre && son>1 )  cut[u]=true;
    if(u== pre)  add_block[u]=son-1;
    Instack[u]=false;
    top--;
}
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}
void solve(int N){
    memset(DFN,0,sizeof(DFN));
    memset(Instack,false,sizeof(Instack));
    memset(add_block,0,sizeof(add_block) );
    memset(cut,false,sizeof(cut) );
    Index=top=block=bridge=0;
    for(int i=1;i<=N;i++)
        if(!DFN[i]){
           block++;
           Tarjan(i,i);
        }
}
struct ans{
    int u,v;
};
bool cmp(ans a,ans b){
    if(a.u==b.u)
        return a.v<b.v;
    else
        return a.u<b.u;
}
int main(){
    int n;
    //freopen("1.txt","r",stdin);
    while(~scanf("%d",&n)){
        int m=0;
        init();
        // 要判断重边，因为我们的有向边和无向边是要建在一起的。
        for(int i=0;i<n;i++){
            int u,v_num;
            scanf("%d (%d)",&u,&v_num);
            u++;
            for(int k=0;k<v_num;k++){
                int v;
                scanf("%d",&v);
                v++;
               if(u>=v) continue; //处理重边
               addedge(u,v);
               addedge(v,u);
//             printf("add=%d %d\n",u,v);
               m+=2;
            }
        }
        solve(n);
        printf("%d critical links\n",bridge);
        for(int i=0;i<m;i+=2){
            if(edge[i].cut==1){
                printf("%d - %d\n",uu[i]-1,edge[i].to-1);
            }
        }
        printf("\n");

    }
    return 0;
}