【HDU 4612 Warm up】BCC 树的直径

题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=4612

题意：一个包含n个节点m条边的无向连通图（无自环，可能有重边）。求添加一条边后最少剩余的桥的数目。

思路：要想尽可能地消灭桥，那么添加的这条边一定是连通了最多的BCC。

　　所以首先进行双连通分量分解，并记录桥的数目；然后将同属一个BCC的点缩成一个，代之以block序号，以block序号为点将原图重构为一棵树。

　　最后求树的直径，桥的数目减去树的直径即为答案。

整体框架是学习了 http://www.cnblogs.com/kuangbin/archive/2013/07/25/3214879.html 的代码。一些细节是自己想的。

学习到的缩点的姿势：在BCC分解后，为每条边是否为桥打上了标记，同时belong数组已记录了每个点所属的连通块号（关节点每次不退栈，而归属于它所找到的最后一个BCC）；这时遍历一遍所有点，如果点 u 所邻接的某条边 i 是桥，那么这条边一定是重构出树中的边，即这条边的终点为 v ，假如用vector<int>形的邻接表 G 存新图，此时应在u和v各自所属的连通块之间加一条边，即G[belong[u]].push_back(belong[v])。

学习到的处理重边的姿势：先把所有边按字典序排序，此时重边必然紧邻，所以addEdge时判一下相邻的边是否相同即可决定这条边是否打重边标记。

这里我用两重while循环、一个flagDup标记以及两个指针cur, i来处理，有点像尺取法：i 与 cur相同的话一直向前走，当遇到第一个 i != cur 时，通过判flagDup来决定当前从开始cur 到 i 之前的边是否打重边标记。开始在边界判断上出了点问题，注意内层循环要保证 i < m。

由于是无向图，同一条边在两个端点各登记一次，所以在边数组里有两个副本，但可以保证两条边的序号仅相差1，这样也可以通过与 1 异或方便地找到另一个副本。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#define CLEAR(A, X) memset(A, X, sizeof(A))
#define REP(N) for(int i=0; i<(N); i++)
#define REPE(N) for(int i=1; i<=(N); i++)
#define FREAD(FN) freopen((FN), "r", stdin)
#define pb(a) push_back(a)

using namespace std;

const int MAX_N = 200005;
const int MAX_M = 2000005;

struct Edge
{
    int v, next;
    bool isBrg;
    bool more;//重边
}edges[MAX_M];

int head[MAX_N], numE;
int low[MAX_N], dfn[MAX_N], S[MAX_N], belong[MAX_N];
int clock, topS;
int block;
bool inStack[MAX_N];
int numBrg;

void addEdge(int u, int v, bool isDup){
    edges[numE].v = v;
    edges[numE].next = head[u];
    edges[numE].isBrg = 0;
    edges[numE].more = isDup;//是否重边
    head[u] = numE++;

    //反向边，序号仅差1
    edges[numE].v = u;
    edges[numE].next = head[v];
    edges[numE].isBrg = 0;
    edges[numE].more = isDup;
    head[v] =numE++;
}

void bcc(int u, int p, bool isDup){
    low[u] = dfn[u] = ++clock;
    S[topS++] = u;
    inStack[u] = 1;
    for(int i=head[u]; i != -1; i = edges[i].next){
        int v = edges[i].v;
        if(v == p && (!isDup)) continue;//parent and no duplicate
        if(!dfn[v]){//tree
            bcc(v, u, edges[i].more);
            low[u] = min(low[u], low[v]);
            if(low[v] > dfn[u]){//bridge
                numBrg++;
                edges[i].isBrg = 1;
                edges[i^1].isBrg = 1;
            }
        }else if(inStack[v])//backward or parent
            low[u] = min(low[u], dfn[v]);//include parent
    }
    if(low[u] == dfn[u]){//new bcc
        block++;
        int t;
        do{
            t = S[--topS];
            inStack[t] = 0;
            belong[t] = block;
        }while(t != u);
    }
}

void init(){
    numE = 0;
    numBrg = 0;
    CLEAR(head, -1);
    CLEAR(low, 0); CLEAR(dfn, 0); 
    CLEAR(inStack, 0);
    CLEAR(belong, 0);
    clock = block = topS = 0;
}

vector<int> G[MAX_N];//缩点后的新图
int dep[MAX_N];

void dfs(int u){
    for(int i=0; i<G[u].size(); i++){
        int v = G[u][i];
        if(dep[v] == -1){
            dep[v] = dep[u]+1;
            dfs(v);
        }
    }
}

int n, m;
struct Node
{
    int u, v;
}nodes[MAX_M];
bool cmp(Node a, Node b){
    if(a.u == b.u) return a.v < b.v;
    return a.u < b.u;
}
bool same(Node a, Node b){
    if(a.u == b.u && a.v == b.v) return true;
    return false;
}

int main()
{
    FREAD("4612.txt");
    while(~scanf("%d%d", &n, &m) && n && m){
        init();
        for(int i=0; i<m; i++){
            int u, v;
            scanf("%d%d", &u, &v);
            if(u > v) swap(u, v);
            nodes[i].u = u; nodes[i].v = v;
        }
        sort(nodes, nodes+m, cmp);//将重边聚到一起
        int cur = 0, i = 1;
        int flagDup = 0;
        while(cur < m){
            while(i<m && same(nodes[cur], nodes[i])){
                flagDup = 1;//与cur重
                i++;
            }
            if(flagDup) addEdge(nodes[cur].u, nodes[cur].v, 1);
            else addEdge(nodes[cur].u, nodes[cur].v, 0);
            //printf("add edge %d %d
", nodes[cur].u, nodes[cur].v);
            flagDup = 0;
            cur = i++;
        }
        
        bcc(1, 0, 0);//0->1虚拟边
        REPE(block) G[i].clear();//block个节点的图
        REPE(n){//以block为编号,[1,block]建新图
            for(int j=head[i]; j!=-1; j=edges[j].next){
                if(edges[j].isBrg){
                    int u = i;
                    int v = edges[j].v;
                    G[belong[u]].pb(belong[v]);//缩点
                }
            }
        }
        CLEAR(dep, -1);
        dep[1] = 0;//以1为根
        dfs(1);
        int deepest = 1, maxDep = -1;
        REPE(block){//找到最深的
            if(dep[i] > dep[deepest]){
                maxDep = dep[deepest];
                deepest = i;
            }
        }
        CLEAR(dep, -1);
        dep[deepest] = 0;//以deepest为根
        dfs(deepest);
        int len = 0;//树的直径
        REPE(block) len = max(len, dep[i]);

        printf("%d
", numBrg - len);
    }
    return 0;
}

这道题从MLE改到WA改到RE再改到TLE，最终弃掉自己的版本学习了bin神的。发现他的实现很真实地反映了思路，比如bcc时，增加父节点p和边属性isDup两个参数，这样就通过v!=p && (!isDup)把无重边的父子边过滤掉，剩下真的后向边和有重边的父子边。我在从思路到代码的转换上还需要多加练习。