UVA315 Network(Tarjan求无向图割点的数目)

Describle

A Telephone Line Company (TLC) is establishing a new telephone cable
network. They are connecting several places numbered by integers from
1 to N. No two places have the same number. The lines are
bidirectional and always connect together two places and in each place
the lines end in a telephone exchange. There is one telephone exchange
in each place. From each place it is possible to reach through lines
every other place, however it need not be a direct connection, it can
go through several exchanges. From time to time the power supply fails
at a place and then the exchange does not operate. The officials from
TLC realized that in such a case it can happen that besides the fact
that the place with the failure is unreachable, this can also cause
that some other places cannot connect to each other. In such a case we
will say the place (where the failure occured) is critical. Now the
officials are trying to write a program for finding the number of all
such critical places. Help them.

Input

The input file consists of several blocks of lines. Each block
describes one network. In the first line of each block there is the
number of places N < 100. Each of the next at most N lines contains
the number of a place followed by the numbers of some places to which
there is a direct line from this place. These at most N lines
completely describe the network, i.e., each direct connection of two
places in the network is contained at least in one row. All numbers in
one line are separated by one space. Each block ends with a line
containing just ‘0’. The last block has only one line with N = 0.

Output

The output contains for each block except the last in the input file
one line containing the number of critical places.

Sample Input

5
5 1 2 3 4
0
6
2 1 3
5 4 6 2
0
0

Sample Output

1
2

思路

这个题目的题意是给你一个无向图，让你求一下关键点的数目，也就是割点的数目。

我们用Tarjan算法，要注意的是输入稍微难处理一点,建图的时候可以用一个邻接矩阵去一下重边

代码

#include <cstdio>
#include <cstring>
#include <cctype>
#include <stdlib.h>
#include <string>
#include <map>
#include <iostream>
#include <stack>
#include <cmath>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long ll;
#define inf 0x3f3f3f3f
#define mem(a,b) memset(a,b,sizeof(a))
const int N=10000+20;
const int M=1e6+10;
struct edge
{
    int v,next;
    bool cut;//是否为桥
} e[M];
int first[N],tot;
int low[N],dfn[N],Stack[N];
//dfn[i]代表i在深度优先搜索中的访问序号
//low[i]代表从i或i的子孙出发，通过回边可以到达的最低深度优先数
int Index,top;
bool instack[N];
bool cut[N];
int add_block[N];//删除一个点后增加的连通快
int bridge;

void add_edge(int u,int v)
{
    e[tot].v=v;
    e[tot].next=first[u];
    e[tot].cut=false;
    first[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=first[u]; ~i; i=e[i].next)
    {
        v=e[i].v;
        if(v==pre) continue;
        if(!dfn[v])
        {
            son++;
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
            //桥
            //一条无向边(u,v)是桥，满足dfn[u]<low[v]
            if(low[v]>dfn[u])//当是桥时
            {
                bridge++;
                e[i].cut=true;
                e[i^1].cut=true;
            }
            //割点的条件是dfn[u]<=low[v]
            if(u!=pre&&low[v]>=dfn[u])
            {
                cut[u]=true;
                add_block[u]++;
            }
        }
        else
            low[u]=min(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 solve(int n)
{
    mem(dfn,0);
    mem(instack,0);
    mem(add_block,0);
    mem(cut,0);
    Index=top=0;
    bridge=0;
    for(int i=1; i<=n; i++)
        if(!dfn[i])
            tarjan(i,i);
    int ans=0;
    for(int i=1; i<=n; i++)
        if(cut[i])
            ans++;
    printf("%d\n",ans);
}
void init()
{
    tot=0;
    mem(first,-1);
}
char s[1100];
int g[110][110];
int main()
{
    int n;
    while(~scanf("%d",&n)&&n)
    {
        gets(s);
        mem(g,0);
        while(gets(s))
        {
            if(strcmp(s,"0")==0) break;
            char *p=strtok(s," ");
            int u;
            sscanf(p,"%d",&u);
            p=strtok(NULL," ");
            int v;
            while(p)
            {
                sscanf(p,"%d",&v);
                p=strtok(NULL," ");
                g[u][v]=g[v][u]=1;
            }
        }
        init();
        for(int i=1; i<=n; i++)
            for(int j=i+1; j<=n; j++)
                if(g[i][j])
                {
                    add_edge(i,j);
                    add_edge(j,i);
                }
        solve(n);
    }
    return 0;
}