POJ 1523 SPF(割点)

大致题意:

给出一个连通的无向图,求哪些点是割点,对于每个割点,求出去掉这个点后连通分量的个数。如果没有割点的话输出“ No SPF nodes”。

思路:

求割点用tarjan即可,然后要求删除割点后连通分量的个数,每次找到割点,再在从割点dfs即可,也可以直接在tarjan算法中记录child个数。那么如果割点是根,那么答案就是child,不是根的割点答案是child+1

//188K	0MS	C++	2121B
#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 1010;
int head[N];
struct Edge
{
    int v,next;
}es[N*N];
struct node
{
    int u;
    int cnt;
}ans[N];
int n;
int cnt;
int dfn[N],low[N];
int index,top=0;
bool vis[N];

bool book[N];
void tarjan(int u,int rt,int pa)
{
    dfn[u]=low[u]=++index;
    int child=0;
    for(int i=head[u];~i;i=es[i].next)
    {
        int v=es[i].v;
        if(dfn[v]==0)
        {
            tarjan(v,rt,u);
            low[u]=min(dfn[u],low[v]);
            if(low[v]>=dfn[u]) child++;
        }
        if(v!=pa) low[u]=min(dfn[u],low[v]);
    }
    if(u==rt&&child>1) ans[++top].u=u,ans[top].cnt=child;
    else if(u!=rt&&child) ans[++top].u=u,ans[top].cnt=child+1;
}
void ini()
{
    memset(head,-1,sizeof(head));
    cnt=0;
    n=-1;
    memset(dfn,0,sizeof(dfn));
    memset(book,0,sizeof(book));
    top=index=0;
}
bool cmp(const node &a,const node&b)
{
    return a.u<b.u;
}
int main()
{
    int u,v;
    int cas=0;
    while(scanf("%d%d",&u,&v)== 2)
    {
        printf("Network #%d\n",++cas);
        ini();
        n=max(n,u);
        n=max(v,n);
        es[++cnt].v=v;
        es[cnt].next=head[u];
        head[u]=cnt;
        es[++cnt].v=u;
        es[cnt].next=head[v];
        head[v]=cnt;
        while(1)
        {
            scanf("%d",&u);
            if(u==0) break;
            scanf("%d",&v);
            es[++cnt].v=v;
            es[cnt].next=head[u];
            head[u]=cnt;
            es[++cnt].v=u;
            es[cnt].next=head[v];
            head[v]=cnt;
            n=max(max(u,v),n);
        }

        for(int i=1;i<=n;i++)
            if(dfn[i]==0) tarjan(i,i,-1);

        sort(ans+1,ans+1+top,cmp);
        if(top==0) printf("  No SPF nodes\n");
        for(int i=1;i<=top;i++)
        {
            printf("  SPF node %d leaves %d subnets\n",ans[i].u,ans[i].cnt);
        }
        puts("");
    }
    return 0;
}
时间: 2024-11-13 20:07:26

POJ 1523 SPF(割点)的相关文章

POJ - 1523 SPF(割点)

题目大意:给出一张图,问去割点后,连通分量的个数有多少 解题思路:割点的水题,套模版就可以 不得不吐槽一下输入.. #include <cstdio> #include <cstring> #define min(a,b) ((a)<(b)?(a):(b)) #define N 1010 #define M 2000010 struct Edge{ int to, next; }E[M]; int head[N], num[N], pre[N], lowlink[N]; in

POJ 1523 SPF 割点 Tarjan

SPF Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 9317   Accepted: 4218 Description Consider the two networks shown below. Assuming that data moves around these networks only between directly connected nodes on a peer-to-peer basis, a

POJ 1523 SPF 割点与桥的判断算法-Tarjan

题目链接: POJ1523 题意: 问一个连通的网络中有多少个关节点,这些关节点分别能把网络分成几部分 题解: Tarjan 算法模板题 顺序遍历整个图,可以得到一棵生成树: 树边:可理解为在DFS过程中访问未访问节点时所经过的边,也称为父子边 回边:可理解为在DFS过程中遇到已访问节点时所经过的边,也称为返祖边.后向边 对根节点u,若其有两棵或两棵以上的子树,则该根结点u为割点: 对非叶子节点u(非根节点),若其子树的节点均没有指向u的祖先节点的回边,说明删除u之后,根结点与u的子树的节点不再

POJ 1523 SPF(强连通分量求割点)

题目地址:POJ 1523 这题猛的一看..貌似有点难的样子.不过仔细一想,那个每个割点所分成一次子图不就都能找到这个割点一次吗,那么只要记录下它作为割点的次数再+1不就行了.也算是求割点的裸题吧.这个题的输出很坑...需要注意一下.. 代码如下: #include <iostream> #include <cstdio> #include <string> #include <cstring> #include <stdlib.h> #incl

poj 1523 SPF 求割点以及删除该割点后联通块的数量

SPF Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 7136   Accepted: 3255 Description Consider the two networks shown below. Assuming that data moves around these networks only between directly connected nodes on a peer-to-peer basis, a

POJ 1523 SPF 求割点的好(板子)题!

题意: 给个无向图,问有多少个割点,对于每个割点求删除这个点之后会产生多少新的点双联通分量 题还是很果的 怎么求割点请参考tarjan无向图 关于能产生几个新的双联通分量,对于每个节点u来说,我们判断他是否是割点,即判断是否满足他的儿子v的low[v]>dfn[u] 而这个时候割掉这个点就会让双联通分量增加,所以搞一个数组记录一下这个操作的次数就行 请注意在是否是根节点的问题上特判 !!注意输出格式!! 1 #include<cstdio> 2 #include<algorithm

poj 1523 SPF 无向图求割点

SPF Description Consider the two networks shown below. Assuming that data moves around these networks only between directly connected nodes on a peer-to-peer basis, a failure of a single node, 3, in the network on the left would prevent some of the s

poj 1523 SPF

SPF http://poj.org/problem?id=1523 Time Limit: 1000MS   Memory Limit: 10000K       Description Consider the two networks shown below. Assuming that data moves around these networks only between directly connected nodes on a peer-to-peer basis, a fail

POJ 1523 SPF 解题报告

思路:使用tarjan算法求出割点,在枚举去掉每一个割点所能形成的联通块的个数. 注意:后来我看了下别的代码,发现我的枚举割点的方式是比较蠢的方式,我们完全可以在tarjan过程中把答案求出来,引入一下讨论: 如果这个割点是根节点,在tarjan算法中搜到几个孩子结点(low[v] >= dfn[u]),他就能割出几个联通块,如果这个割点是孩子结点,那么他所形成的联通块的个数+1,因为他还有一条与父亲结点间接或直接相连的边. 代码如下: #include<map> #include<