HDU 4612 Warm up【双连通缩点(BCC去重边)+染色建新图+树的直径】

Problem Description
　　N planets are connected by M bidirectional channels that allow instant transportation. It’s always possible to travel between any two planets through these channels.
　　If we can isolate some planets from others by breaking only one channel , the channel is called a bridge of the transportation system.
People don’t like to be isolated. So they ask what’s the minimal number of bridges they can have if they decide to build a new channel.
　　Note that there could be more than one channel between two planets.
Input
　　The input contains multiple cases.
　　Each case starts with two positive integers N and M , indicating the number of planets and the number of channels.
　　(2<=N<=200000, 1<=M<=1000000)
　　Next M lines each contains two positive integers A and B, indicating a channel between planet A and B in the system. Planets are numbered by 1..N.
　　A line with two integers ‘0’ terminates the input.
Output
　　For each case, output the minimal number of bridges after building a new channel in a line.
Sample Input
4 4
1 2
1 3
1 4
2 3
0 0
Sample Output
0

Author
SYSU
Source
2013 Multi-University Training Contest 2

题意：给你n个点，m条无向边，现在让你加一条无向边，使得无向图的桥数变得最少。
分析：
无向图加边求最少桥数。既然要加边，就涉及到 双连通缩点+建新图，预处理出新图后，就是加边求桥数了。注意新图(其实是树)的每一条边都是桥，所以找树的直径就可以了，将首尾连接就最大化的减少桥数了，最终结果就是：ans = 桥数-树的直径;

*这道题经典部分是双联通缩点，以前去重边的时候用map，一直MLE，用结构体+排序去重边可以防止MLE；

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;

const int MAXN = 200000 + 5;
int low[MAXN], dfn[MAXN], Head[MAXN];
int vis[MAXN], dist[MAXN], stack[MAXN], col[MAXN];
int index_, p, cnt, top, scc;
vector<int> G[MAXN];

struct node_ {
    int to;
    int next;
    bool flag;
    bool cut;
}Edge[MAXN * 10];

struct Node {
    int a;
    int b;
}s[MAXN * 10];

void addEdge(int u, int v, bool Flag) {
    Edge[cnt].to = v;
    Edge[cnt].next = Head[u];
    Edge[cnt].flag = Flag; //标记重边
    Edge[cnt].cut = false;
    Head[u] = cnt++;
}

inline void tarjan(int u, int fa, bool tt) {
    int v;
    low[u] = dfn[u] = ++index_;
    stack[top++] = u;
    vis[u] = 1;
    for(int i = Head[u]; ~i; i = Edge[i].next) {
        v = Edge[i].to;
        if(v == fa && tt) continue; //缩点时考虑到重边
        if(!dfn[v]) {
            tarjan(v, u, Edge[i].flag);
            low[u] = min(low[v], low[u]);
            if(low[v] > dfn[u]) { //原图的桥
                p++;
                Edge[i].cut = true;
                Edge[i ^ 1].cut = true;
            }
        }
        else if(vis[v] && low[u] > dfn[v]) {
            low[u] = dfn[v];
        }
    }
    if(low[u] == dfn[u]) {
        scc++;
        do {
            v = stack[--top];
            vis[v] = 0;
            col[v] = scc; //建新图必要的缩点染色
        } while(v != u);
    }
}

bool cmp(Node x, Node y) {
    if(x.a != y.a) return x.a < y.a;
    return x.b < y.b;
}

void init() { 
    memset(dfn, 0, sizeof(dfn));
    memset(Head, -1, sizeof(Head));
    memset(s, 0, sizeof(s));
    memset(vis, 0, sizeof(vis));
    memset(col, 0, sizeof(col));
    scc = top = p = index_ = cnt = 0;
    for(int i = 0; i < MAXN; ++i) {
        G[i].clear();
    }
}

int ans = 0, node;
void dfs(int u, int fa, int L) {
    for(int i = 0; i < G[u].size(); ++i) {
        int v = G[u][i];
        if(v == fa) continue;
        dfs(v, u, L + 1);
    }
    if(ans < L) {
        ans = L;
        node = u;
    }
}

//int node, ans = 0;
//void BFS(int start)  //BFS求树的直径也可以
//{  
//    queue<int> Q;  
//    memset(dist, 0, sizeof(dist));  
//    memset(vis, 0, sizeof(vis));  
//    node = start;  
//    ans = 0;  
//    vis[start] = 1;  
//    Q.push(start);  
//    while(!Q.empty())  
//    {  
//        int u = Q.front();  
//        Q.pop();  
//        for(int i = 0; i < G[u].size(); ++i)  
//        {
//            int v = G[u][i];
//            if(!vis[v])  
//            {  
//                dist[v] = dist[u] + 1;  
//                if(dist[v] > ans)  
//                {  
//                    ans = dist[v];  
//                    node = v;  
//                }   
//                vis[v] = 1;   
//                Q.push(v);  
//            }   
//        }  
//    }  
//}  

void solve(int n) {
    for(int i = 1; i <= n; ++i) {
        if(!dfn[i]) {
            tarjan(i, -1, true);
        }
    }
    if(!p) {
        printf("0\n");
        return ;
    }
    for(int i = 1; i <= n; ++i) { //建新图
        for(int j = Head[i]; ~j; j = Edge[j].next) {
            if(Edge[j].cut) {
                G[col[Edge[j].to]].push_back(col[i]);
            }
        }
    }
//  ans = 0;
//  BFS(1);
//  ans = 0;
//  BFS(node);
    ans = 0;
    dfs(1, -1, 0); //dfs求树的直径
    ans = 0;
    dfs(node, -1, 0);
    printf("%d\n", p - ans);
}

int main() {
    int n, m, T;
    while(scanf("%d %d", &n, &m) && (n + m)) {
        init();
        int A, B;
        for(int i = 0; i < m; ++i) {
            scanf("%d %d", &A, &B);
            if(A == B) continue;
            s[i].a = min(A, B);
            s[i].b = max(A, B);
        }
        sort(s, s + m, cmp);
        for(int i = 0; i < m; ++i) { //去重边，防MLE
            if(!i || (s[i].a != s[i - 1].a || s[i].b != s[i - 1].b)) {
                if(s[i].a == s[i + 1].a && s[i].b == s[i + 1].b) {
                    addEdge(s[i].a, s[i].b, false);
                    addEdge(s[i].b, s[i].a, false);
                }
                else {
                    addEdge(s[i].a, s[i].b, true);
                    addEdge(s[i].b, s[i].a, true);
                }
            }
        }
        solve(n);
    }
    return 0; 
}