Critical Links （Tarjan 求割边）

Critical Links

In a computer network a link L, which interconnects two servers, is 
considered critical if there are at least two servers A and B such 
that all network interconnection paths between A and B pass through L. 
Removing a critical link generates two disjoint sub–networks such that 
any two servers of a sub–network are interconnected. For example, the 
network shown in figure 1 has three critical links that are marked 
bold: 0 -1, 3 - 4 and 6 - 7. Figure 1: Critical links It is known 
that: 
1. the connection links are bi–directional; 
2. a server is not directly connected to itself; 
3. two servers are interconnected if they are directly connected or if they are interconnected with the same server; 
4. the network can have stand–alone sub–networks. Write a program that finds all critical links of a given computer network.

Input
The program reads sets of data from a text file. Each data set 
specifies the structure of a network and has the format: no of servers 
server0 (no of direct connections) connected server … connected 
server … serverno of servers (no of direct connections) connected 
server … connected server The first line contains a positive 
integer no of servers(possibly 0) which is the number of network 
servers. The next no of servers lines, one for each server in the 
network, are randomly ordered and show the way servers are connected. 
The line corresponding to serverk, 0 ≤ k ≤ no of servers − 1, 
specifies the number of direct connections of serverk and the servers 
which are directly connected to serverk. Servers are represented by 
integers from 0 to no of servers − 1. Input data are correct. The 
first data set from sample input below corresponds to the network in 
figure 1, while the second data set specifies an empty network.

Output
The result of the program is on standard output. For each data set the 
program prints the number of critical links and the critical links, 
one link per line, starting from the beginning of the line, as shown 
in the sample output below. The links are listed in ascending order 
according to their first element. The output for the data set is 
followed by an empty line.

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
1
2
3
4
5
6
7
8
9
10
Sample Output
3 critical links
0 - 1
3 - 4
6 - 7
0 critical links

 

题目大意：给出一个n点无向图，求割边的数量，并按顺序输出割边信息

桥（割边）：无向联通图中，去掉一条边，图中的连通分量数增加，则这条边，称为桥或者割边。

当low[v]>dfn[u]时，表示v节点只能通过该边(u,v)与u连通，那么(u,v)即为割边

 

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<stack>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
const int N=1e5+20;
const int M=1e6+20;
int first[N],dfn[N],low[N],cut[M];
int tot,time,cnt,bri; //bri记录桥的数量
stack<int>s;
struct node
{
    int v,next;
    bool cut;  //标桥
}e[M];
void init()  //初始化
{
    mem(first,-1);
    mem(dfn,0);
    mem(low,0);
    tot=time=cnt=bri=0;
    while(!s.empty())s.pop();
}
void adde(int u,int v)  //建边
{
    e[tot].v=v;
    e[tot].next=first[u];
    e[tot].cut=0;
    first[u]=tot++;
}
void tarjan(int u,int pre)
{
    dfn[u]=low[u]=++time;
    s.push(u);
    for(int i=first[u];~i;i=e[i].next)
    {
        int v=e[i].v;
        if(v==pre)continue; 
        if(!dfn[v])
        {
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
            if(low[v]>dfn[u])  //判断是否是桥
            {
                bri++;
                e[i].cut=1;
                e[i^1].cut=1;
            }
        }
        else low[u]=min(low[u],dfn[v]);
    }
}
struct poin
{
    int x,y;
}a[M];
bool cmp(poin a,poin b)
{
    if(a.x==b.x)
        return a.y<b.y;
    return a.x<b.x;
}
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        init();
        int x,k,y;
        for(int i=0;i<n;i++)
            {
                scanf("%d (%d)",&x,&k);
                while(k--)
                {
                    scanf("%d",&y);
                    if(x>=y)continue;
                    adde(x+1,y+1);
                    adde(y+1,x+1);
                }
            }
        for(int i=1;i<=n;i++)
            if(!dfn[i])
            tarjan(i,i);
        printf("%d critical links\n",bri);
        int ans=0;
        for(int i=1;i<=n;i++)
            for(int j=first[i];~j;j=e[j].next)
            if(e[j].cut&&e[j].v>i)  //记录桥
                {
                    a[ans].x=i-1;
                    a[ans++].y=e[j].v-1;
                }
        sort(a,a+bri,cmp); 
        for(int i=0;i<bri;i++)
            printf("%d - %d\n",a[i].x,a[i].y);
        printf("\n");
    }
    return 0;
}