hiho一下 连通性二·边的双连通分量

原创 2015年07月10日 17:33:55
时间限制:10000ms
单点时限:1000ms
内存限制:256MB

描述

在基本的网络搭建完成后,学校为了方便管理还需要对所有的服务器进行编组,网络所的老师找到了小Hi和小Ho,希望他俩帮忙。

老师告诉小Hi和小Ho:根据现在网络的情况,我们要将服务器进行分组,对于同一个组的服务器,应当满足:当组内任意一个连接断开之后,不会影响组内服务器的连通性。在满足以上条件下,每个组内的服务器数量越多越好。

比如下面这个例子,一共有6个服务器和7条连接:

其中包含2个组,分别为{1,2,3},{4,5,6}。对{1,2,3}而言,当1-2断开后,仍然有1-3-2可以连接1和2;当2-3断开后,仍然有2-1-3可以连接2和3;当1-3断开后,仍然有1-2-3可以连接1和3。{4,5,6}这组也是一样。

老师把整个网络的情况告诉了小Hi和小Ho,小Hi和小Ho要计算出每一台服务器的分组信息。

   

提示:边的双连通分量

 

输入

第1行:2个正整数,N,M。表示点的数量N,边的数量M。1≤N≤20,000, 1≤M≤100,000

第2..M+1行:2个正整数,u,v。表示存在一条边(u,v),连接了u,v两台服务器。1≤u<v≤N

保证输入所有点之间至少有一条连通路径。

输出

第1行:1个整数,表示该网络的服务器组数。

第2行:N个整数,第i个数表示第i个服务器所属组内,编号最小的服务器的编号。比如分为{1,2,3},{4,5,6},则输出{1,1,1,4,4,4};若分为{1,4,5},{2,3,6}则输出{1,2,2,1,1,2}





样例输入
6 7
1 2
1 3
2 3
3 4
4 5
4 6
5 6
样例输出
2
1 1 1 4 4 4
提示:

对于一个无向图,当我们把图中所有的桥都去掉以后,剩下的每一个区域就是我们要求的边的双连通分量。比如:

其中{1,2,3},{4,5,6},{7}各为一个组。

直观的做法自然先用上周的算法求出所有桥,去掉所有桥之后再做DFS求出每一个连通子图。我们这周要介绍一种更"抽象"的算法,通过在Tarjan算法当中巧妙地用一个栈来统计出每一个组内的节点,其代码如下:

void dfs(int u) {
    //记录dfs遍历次序
    static int counter = 0;    
    
    //记录节点u的子树数
    int children = 0;
    
    ArcNode *p = graph[u].firstArc;
    visit[u] = 1;

    //初始化dfn与low
    dfn[u] = low[u] = ++counter;
    
    //将u加入栈
    stack[++top] = u;

    for(; p != NULL; p = p->next) {
        int v = p->adjvex;
        
        //节点v未被访问,则(u,v)为树边
        if(!visit[v]) {
            children++;
            parent[v] = u;
            dfs(v);

            low[u] = min(low[u], low[v]);
            if (low[v] > dfn[u]) {
                printf("bridge: %d %d\n", u, v);    // 该边是桥
                bridgeCnt++;  
            }
        }

        //节点v已访问,则(u,v)为回边
        else if(v != parent[u]) {
            low[u] = min(low[u], dfn[v]);
        }
    }
    
    if (low[u] == dfn[u])
    {
        // 因为low[u] == dfn[u],对(parent[u],u)来说有dfn[u] > dfn[ parent[u] ],因此low[u] > dfn[ parent[u] ]
        // 所以(parent[u],u)一定是一个桥,那么此时栈内在u之前入栈的点和u被该桥分割开
        // 则u和之后入栈的节点属于同一个组
        将从u到栈顶所有的元素标记为一个组,并弹出这些元素。
    }
}

完整代码:
#include <iostream>
#include <string.h>
#include <cstdio>
#include <set>
#include <algorithm>
using namespace std;
#define maxn 20100
#define maxe 200100
struct Edge
{
    int v,next;
}E[maxe];
int dfn[maxn],low[maxn],head[maxn],Stack[maxn],Belong[maxn],parent[maxn],counter,len,Stop,n, MinVlaue,m,ans;
void AddEdge(int a, int b)
{
    len++;
    E[len].v = b;
    E[len].next = head[a];
    head[a] = len;
}
void dfs(int u)
{
    int v;
    dfn[u] = low[u]=++counter; //初始化dfn与low
    Stack[Stop++]=u; //将u加入栈
    for (int i = head[u]; i!=-1; i = E[i].next)
    {
        v = E[i].v;
        if (!dfn[v])  //节点v未被访问,则(u,v)为树边
        {
            parent[v]=u;
            dfs(v);
            low[u] = min(low[u], low[v]);
            if(low[v]>dfn[u])
            {
                //printf("bridge: %d %d\n", u, v);    // 该边是桥
            }
        }
        //节点v已访问,则(u,v)为回边
        else if(v != parent[u])
        {
            low[u] = min(low[u], dfn[v]);
        }
    }

    if(low[u]==dfn[u])
    {
        // 因为low[u] == dfn[u],对(parent[u],u)来说有dfn[u] > dfn[ parent[u] ],因此low[u] > dfn[ parent[u] ]
        // 所以(parent[u],u)一定是一个桥,那么此时栈内在u之前入栈的点和u被该桥分割开
        // 则u和之后入栈的节点属于同一个组
        //将从u到栈顶所有的元素标记为一个组,并弹出这些元素。
        ans++;
        int temp=Stop-1;
        while (Stack[temp]!=u)
        {
            temp--;
        }
        MinVlaue=*min_element(Stack+temp, Stack+Stop);
        do
        {
           
            v=Stack[--Stop];
            Belong[v]=MinVlaue;
        }while (u!=v);
    }
    
}

int main()
{
    int a,b;
    while (scanf("%d%d", &n, &m)!=EOF)
    {
        memset(head, -1, sizeof(head));
        memset(parent, 0, sizeof(parent));
        counter=0;
        ans=0;
        Stop=0;
        memset(dfn,0, sizeof(dfn));
        for (int i = 1; i <= m; i++)
        {
            scanf("%d%d", &a, &b);
            AddEdge(a,b);
            AddEdge(b,a);
        }
        dfs(1);
        printf("%d\n",ans);
        for (int i=1; i<=n; i++)
        {
            printf("%d ",Belong[i]);
        }
    }
    return 0;
}







版权声明:欢迎互相学习

hihocoder #1184 : 连通性二·边的双连通分量

时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 在基本的网络搭建完成后,学校为了方便管理还需要对所有的服务器进行编组,网络所的老师找到了小...
  • hyf20144055065
  • hyf20144055065
  • 2016年01月18日 19:38
  • 242

hihoCoder_#1184_连通性二·边的双连通分量

#1184 : 连通性二·边的双连通分量 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 在基本的网络搭建完成后,学校为了方便管理还需要对所有的服务器进行编组,...
  • jhgkjhg_ugtdk77
  • jhgkjhg_ugtdk77
  • 2015年07月31日 22:11
  • 952

tarjan算法(边的双连通分量)

hiho链接:http://hihocoder.com/contest/hiho53/problem/1 边的双连通分量定义:对于一个无向图的子图,当删除其中任意一条边后,不改变图内点的连通...
  • qwe2434127
  • qwe2434127
  • 2015年08月09日 18:05
  • 1292

poj 3177 poj 3352 (边双连通分量裸题+缩点)

题目:http://poj.org/problem?id=3177 题意: 这两题几乎一样,都是给一个连通图,问最少加几条边可以得到边双连通图。 分析: 先求出边双连通分量(low[i]值相...
  • hjt_fathomless
  • hjt_fathomless
  • 2016年10月02日 19:12
  • 190

Tarjan三大算法之双连通分量(双连通分量)

定义: 对于一个连通图,如果任意两点至少存在两条点不重复路径,则称这个图为点双连通的(简称双连通);如果任意两点至少存在两条边不重复路径,则称该图为边双连通的。点双连通图的定义等价于任意两条边都同在...
  • fuyukai
  • fuyukai
  • 2016年05月03日 16:18
  • 9097

hihoCoder_#1184_连通性二·边的双连通分量

#1184 : 连通性二·边的双连通分量 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 在基本的网络搭建完成后,学校为了方便管理还需要对所有的服务器进行编组,...
  • jhgkjhg_ugtdk77
  • jhgkjhg_ugtdk77
  • 2015年07月31日 22:11
  • 952

无向图的割顶和桥,无向图的双连通分量入门详解及模板

割顶和桥:对于无向图G,如果删除某个节点u后,连通分量数目增加,则称u为图的割顶;如果删除某条边后,连通分量数目增加,则称该边为图的桥。对于连通图删除割顶或桥后都会使得图不再连通以下我,我们利用dfs...
  • STILLxjy
  • STILLxjy
  • 2017年04月14日 22:56
  • 1196

poj3177Redundant Paths【构造双连通分量:并查集缩点 模板】

这个题就是问加几条边可以构成双连通分量,一开始图样图森破的以为只是求桥的个数就好,然而并非如此…… 构造双连通分量的加边数=(原图的叶节点数+1)/2    因为双连通分量需要成环嘛,原图已经是连着的...
  • zhou_yujia
  • zhou_yujia
  • 2015年11月20日 10:12
  • 584

(POJ 3352)无向图的边双连通分量模板题 + 在一个图中最少加几条边可以使得图边双连通

Road Construction Time Limit: 2000MS Memory Limit: 65536K Total Submissions: 11779 Acc...
  • STILLxjy
  • STILLxjy
  • 2017年04月20日 20:07
  • 415

双连通分量模板以及对一些不好理解点的解释

概念: 双连通分量有点双连通分量和边双连通分量两种。若一个无向图中的去掉任意一个节点(一条边)都不会改变此图的连 通性,即不存在割点(桥),则称作点(边)双连通图。一个无向图中的每一个极大点(边)双连...
  • yo_bc
  • yo_bc
  • 2017年06月09日 18:32
  • 313
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:hiho一下 连通性二·边的双连通分量
举报原因:
原因补充:

(最多只允许输入30个字)