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

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

时间限制: 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

分析：做法其实和有向图的强连通分量差不多。有一点需要注意，无向图不需要判断点是否在栈中。为什么无向图不用标记呢，那时因为，边是无向的，有边从u->v同时也必有边v->u 由于u之前被标记过，而遍历到当前结点v 又不是通过w(u,v)这条边过来的，则必还存在另一条路径可以使u 和v 是相通的，从而u,v是双连通的。

有关图的强连通分量，割点，桥，块，参照：http://blog.csdn.net/shiqi_614/article/details/7833628

题目链接：http://hihocoder.com/problemset/problem/1184

代码清单：

#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cmath>
#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;

const int maxn = 20000 + 5;
const int maxv = 100000 + 5;

int N,M,a,b;
vector<int>graph[maxn];
int dfn[maxn];
int low[maxn];
stack<int>sta;
bool InStack[maxn];
int belong[maxn];
int min_num[maxn];
int idx,sccno;

void init(){
    for(int i=0;i<maxn;i++)
        graph[i].clear();
    while(!sta.empty()) sta.pop();
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(belong,0,sizeof(belong));
    memset(min_num,0,sizeof(min_num));
    memset(InStack,false,sizeof(InStack));
    idx=0; sccno=0;

}

void input(){
    scanf("%d%d",&N,&M);
    for(int i=0;i<M;i++){
        scanf("%d%d",&a,&b);
        graph[a].push_back(b);
        graph[b].push_back(a);
    }
}

void tarjan(int u,int father){
    low[u]=dfn[u]=++idx;
    InStack[u]=true;
    sta.push(u);
    bool flag=true;
    for(int i=0;i<graph[u].size();i++){
        int v=graph[u][i];
        if(v==father) continue;//
        if(!dfn[v]){
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
        }
        else //无向图不需要用栈来标记
            low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u]){
        sccno++;
        min_num[sccno]=u;
        while(!sta.empty()){
            int j=sta.top();
            sta.pop();
            InStack[j]=false;
            belong[j]=sccno;
            min_num[sccno]=min(min_num[sccno],j);
            if(j==u) break;
        }
    }
}

void solve(){
//    for(int i=1;i<=N;i++){
//        if(!dfn[i]) tarjan(i,i);
//    }
    tarjan(1,1);
    printf("%d\n",sccno);
    for(int i=1;i<=N;i++){
        printf("%d ",min_num[belong[i]]);
    }
    printf("\n");
}

int main(){
    init();
    input();
    solve();
    return 0;
}