UVA796（求桥基础题）

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
Sample Output
3 critical links
0 - 1
3 - 4
6 - 7

0 critical links

题意：给你一个网络要求这里面的桥。
输入数据：输入n 个点的编号  （与这个点相连的点的个数m）  依次是m个点的编号
输入到文件结束。
桥输出的时候需要排为字典序

桥就是割边，割点是去掉了这个点和点有关的所有边，割去后图不再连通，而割边是指去掉这个边以后图不再连通。割点是判断条件是low[v]>=dfn[u]（v是u的子节点），其实low[v]=dfn[u]时这俩点是在一个同连通分量里，回想一下代码，而只有low[v]>dfn[u]时说明v跟u不在同一个连通分量里，当我们找到u，v这条边并且low[v]>dfn[u]时，这条边符合了v是u的子树根节点，想去v必须经过u，而且u和v也不在同一个连通分量里边那么这个由u，v组成的边就是我们要的割边也就是桥

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int n,r,cnt,ans;
struct node//邻接表，因为是无向图双向存图，没看清楚数据范围re很多发
{
    int to;
    int next;
}e[11005*1009];//触目惊心的re来源
int first[11005],dfn[11005],low[11005],fa[11005];
struct node1//用来排序的
{
    int x;
    int y;
}a[11005];
void add(int u,int v)
{
    e[r].to=v;
    e[r].next=first[u];
    first[u]=r++;
}
void init()
{
    memset(first,-1,sizeof(first));
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(fa,0,sizeof(fa));
    r=0;
    cnt=1;
    ans=0;
}
bool cmp(node1 b,node1 c)//排序规则
{
    if(b.x!=c.x)
        return b.x<c.x;
    else
        return b.y<c.y;
}
void tarjan(int u,int from)//先跑一遍tarjan，下边再统计桥
{
    dfn[u]=low[u]=cnt++;
    fa[u]=from;
    for(int i=first[u];i!=-1;i=e[i].next)
    {
        int v=e[i].to;
        if(dfn[v]==0)
        {
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
        }
        else if(v!=from)
            low[u]=min(low[u],dfn[v]);
    }
}
void slove()
{
    for(int i=0;i<n;i++)//可能出现多个连通图的现象，需要每次进行查找，一次查找后该连通图的节点的dfn都不为0，借此可以判断是否还有其他连通图
    {
        if(dfn[i]==0)
        {
            printf("*\n");
            tarjan(i,-1);
        }
    }
    int f;//f是用来看祖先是啥，如果f是-1代表这个点i是根节点，这时候没法看是不是桥
    for(int i=0;i<n;i++)
    {
        f=fa[i];
        if(f!=-1&&low[i]>dfn[f])
        {
            a[ans].x=i;
            a[ans].y=f;
            int t;
            if(a[ans].y<a[ans].x)//一切为了排序
            {
                t=a[ans].x;
                a[ans].x=a[ans].y;
                a[ans].y=t;
            }
            ans++;
        }
    }
    printf("%d critical links\n",ans);
    sort(a,a+ans,cmp);
    for(int i=0;i<ans;i++)
    {
        printf("%d - %d\n",a[i].x,a[i].y);
    }
        printf("\n");
}
int main()
{
    int u,num,v;
    while(scanf("%d",&n)!=EOF)
    {
        init();
        for(int i=0;i<n;i++)
        {
            scanf("%d (%d)",&u,&num);
            while(num--)
            {
                scanf("%d",&v);
                add(u,v);
                add(v,u);
            }
        }
        slove();
    }
    return 0;
}