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

0 critical links

https://www.cnblogs.com/c1299401227/p/5402747.html

求无向图的割点和桥

   1.桥：是存在于无向图中的这样的一条边，如果去掉这一条边，那么整张无向图会分为两部分，这样的一条边称为桥无向连通图中，如果删除某边后，图变成不连通，则称该边为桥。

    2.割点：无向连通图中，如果删除某点后，图变成不连通，则称该点为割点。

二：tarjan算法在求桥和割点中的应用

    1.割点：1）当前节点为树根的时候，条件是“要有多余一棵子树”（如果这有一颗子树，去掉这个点也没有影响，如果有两颗子树，去掉这点，两颗子树就不连通了。）

              2）当前节点u不是树根的时候，条件是“low[v]>=dfn[u]”，也就是在u之后遍历的点，能够向上翻，最多到u，如果能翻到u的上方，那就有环了，去掉u之后，图仍然连通。   保证v向上最多翻到u才可以

    2.桥：若是一条无向边（u，v）是桥，

            1）当且仅当无向边（u，v）是树枝边的时候，需要满足dfn(u)<low(v)，也就是v向上翻不到u及其以上的点，那么u--v之间一定能够有1条或者多条边不能删去，因为他们之间有一部分无环，是桥。

            如果v能上翻到u那么u--v就是一个环，删除其中一条路径后，能然是连通的。

    3.注意点：

            1）求桥的时候：因为边是无方向的，所以父亲孩子节点的关系需要自己规定一下，

                                在tarjan的过程中if（v不是u的父节点） low[u]=min(low[u],dfn[v]);

                               因为如果v是u的父亲，那么这条无向边就被误认为是环了。

            2）找桥的时候：注意看看有没有重边，有重边的边一定不是桥，也要避免误判。

    4.也可以先进行tarjan（），求出每一个点的dfn和low，并记录dfs过程中的每个点的父节点，遍历所有点的low，dfn来寻找桥和割点

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<math.h>
#include<stack>
#define nn 1100
#define inff 0x3fffffff
using namespace std;
int n,num,p[nn],dfn[nn],low[nn],ans,fa[nn],df;
struct node
{
    int en,next;
}e[nn*nn];
struct no
{
    int k1,k2;
}pp[nn];
int cmp(no a,no b)
{
    if(a.k1==b.k1)
        return a.k2<b.k2;
    return a.k1<b.k1;
}
int init()
{
    memset(p,-1,sizeof(p));
    num=0;
}
int add(int st,int en)
{
   e[num].en=en;
   e[num].next=p[st];
   p[st]=num++;
}
int dfs(int u,int father)
{
    dfn[u]=low[u]=++df;
    fa[u]=father;//记录每一个点的父亲
    int w;
    for(int i=p[u];i+1;i=e[i].next)
    {
        w=e[i].en;
        if(dfn[w]==-1)
        {
            dfs(w,u);
            low[u]=min(low[u],low[w]);
        }
        else if(father!=w)//如果w是u的父亲，那么这就是无向图的重边，有重边一定不是桥
            low[u]=min(low[u],dfn[w]);
    }
}
int slove()
{
    int p1,p2;
    ans=0;
    df=0;
    memset(fa,-1,sizeof(fa));
    memset(dfn,-1,sizeof(dfn));
    for(int i=0;i<n;i++)
    {
        if(dfn[i]==-1)
            dfs(i,-1);
    }
    for(int i=0;i<n;i++)//只有树边才可能出现桥，回边不会出现桥
    {
        int kk=fa[i];
        if(kk>=0&&low[i]>dfn[kk])//根节点没有父亲节点
        {
            ans++;
            p2=max(kk,i);
            p1=min(kk,i);
            pp[ans].k1=p1;
            pp[ans].k2=p2;
        }
    }
    printf("%d critical links\n",ans);
    sort(pp+1,pp+ans+1,cmp);
    for(int i=1;i<=ans;i++)
    {
        printf("%d - %d\n",pp[i].k1,pp[i].k2);
    }
    printf("\n");
}
int main()
{
    int u,v,m;
    while(~scanf("%d",&n))
    {
        init();
        for(int i=1;i<=n;i++)
        {
            scanf("%d (%d)",&u,&m);
            for(int j=1;j<=m;j++)
            {
                scanf("%d",&v);
                add(u,v);
            }
        }
        slove();
    }
}