POJ 1144 Network

#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
using namespace std;

char s[1000000];
int n,u,v,tot,len,sum;
const int INF=0x7FFFFFFF;
const int MAXN=105;
vector<int>G[MAXN];
int fail[MAXN],flag[MAXN];

void DFS(int now)
{
int i;
for(i=0; i<G[now].size(); i++)
{
if(!flag[G[now][i]]&&!fail[G[now][i]])
{
flag[G[now][i]]=1;
DFS(G[now][i]);
}
}
}

int main()
{
int i,ii;
while(~scanf("%d",&n)&&n)
{
for(i=0; i<=n; i++) G[i].clear();
memset(flag,0,sizeof(flag));
memset(fail,0,sizeof(fail));
while(gets(s))
{
if(strcmp(s,"0")==0) break;
len=strlen(s);
u=INF;
sum=0;
for(i=0; i<=len; i++)
{
if(s[i]==' '||s[i]=='\0')
{
if(u==INF) u=sum,sum=0;
else
{
v=sum,sum=0;
G[u].push_back(v);
G[v].push_back(u);
}
}
else sum=sum*10+s[i]-'0';
}
}

memset(fail,0,sizeof(fail));

int AAA,ans=0;
for(ii=1; ii<=n; ii++)
{
fail[ii]=1;
AAA=0;
memset(flag,0,sizeof(flag));
for(i=1; i<=n; i++)
{
if(fail[i]) continue;
if(!flag[i])
{
flag[i]=1;
DFS(i);
AAA++;
}
}
if(AAA!=1) ans++;
fail[ii]=0;
}
printf("%d\n",ans);
}
return 0;
}

#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
using namespace std;

const int INF=0x7FFFFFFF;
const int maxn=1111;//有多少个结点
vector<int>G[maxn];
int visited[maxn];//标记该节点有没有访问过
int node,edge;//顶点数目
int tmpdfn;//dfs过程中记录当前的深度优先搜索序数
int dfn[maxn];//记录每个顶点的深度优先搜索序数
int low[maxn];//每个顶点的low值，根据该值来判断是否是关节点
int son;//根结点的有多少个孩子，如果大于等于2，则根结点为关节点
int subnets[maxn];//记录每个结点（去掉该结点后）的连通分量的个数
char s[maxn];

/*以下是输出重连通分量用的*/
int top;
struct Edge
{
int u,v;
void output()
{
printf("%d-%d ",u,v);
}
bool cmp(Edge &t)
{
return ((u==t.u&&v==t.v)||(v==t.u&&u==t.v));
}
};
Edge Stack[maxn];
int Flag[maxn][maxn];

void init()
{
for(int i=0; i<maxn; i++) G[i].clear();
low[1]=dfn[1]=1;
tmpdfn=1;
son=0;
memset(visited,0,sizeof(visited));
visited[1]=1;
memset(subnets,0,sizeof(subnets));
}

void dfs(int u)
{
for(int i=0; i<G[u].size(); i++)
{
int v=G[u][i];
Edge t;

/*将这条边压入栈顶*/
if(!Flag[u][v])//没有入过栈
{
t.u=u;
t.v=v;
Stack[++top]=t;
Flag[u][v]=Flag[v][u]=1;
}

if(!visited[v])
{
visited[v]=1;
tmpdfn++;
dfn[v]=low[v]=tmpdfn;
dfs(v);
low[u]=min(low[u],low[v]);
if(low[v]>=dfn[u])
{
if(u!=1) subnets[u]++;
if(u==1) son++;
/*
printf("重连通分量：");
while(1)
{
if(top==-1) break;
Edge t1;
t1=Stack[top];
t1.output();
top--;
if(t1.cmp(t)) break;
}
printf("\n");
*/
}
}
else low[u]=min(low[u],dfn[v]);
}
}

int main()
{
while(~scanf("%d",&node)&&node)//输入节点数量和边的数量
{

init();//初始化

int len,u,v,sum;
while(gets(s))
{
if(strcmp(s,"0")==0) break;
len=strlen(s);
u=INF;
sum=0;
for(int i=0; i<=len; i++)
{
if(s[i]==' '||s[i]=='\0')
{
if(u==INF) u=sum,sum=0;
else
{
v=sum,sum=0;
G[u].push_back(v);
G[v].push_back(u);
}
}
else sum=sum*10+s[i]-'0';
}
}
top=-1;//初始化 栈为空
memset(Flag,0,sizeof(Flag));

//DFS求解割点，点双连通分量，去掉一个个点之后有几个连通分量
/*DFS过程中输出点双连通分量*/
dfs(1);

//计算根节点
if(son>1) subnets[1]=son-1;

int ans=0;

/*输出割点*/
for(int i=1; i<=node; i++)
if(subnets[i])
//printf("%d号节点是割点，删除之后有%d个连通分量\n",i,subnets[i]+1);
ans++;
printf("%d\n",ans);
}
return 0;
}