HDU 4612 Warm up —— （缩点 + 求树的直径）

　　题意：一个无向图，问建立一条新边以后桥的最小数量。

　　分析：缩点以后，找出新图的树的直径，将这两点连接即可。

　　但是题目有个note：两点之间可能有重边！而用普通的vector保存边的话，用v!=fa的话是没办法让重边访问的，因此，使用数组模拟邻接表的方法来储存边。

这样，只要访问了一条边以后，令E[i].vis=E[i^1].vis=1即可，这样可以防止无向图的边和重边搞混。原理就是按位异或，一个奇数^1变为比它小1的偶数，反之亦然：如5^1=4,4^1=5。

　　具体见代码：

#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <stack>
#include <vector>
#include <set>
#include <queue>
//#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;

const int N = 200000+5;

int n,m,dfn[N],low[N];
int head[N];
int tot=0;
int dfs_clock;
int bridge;
int belong[N];
int scc_cnt;
int maxd;
bool vis[N];
vector<int> G[N];
stack<int> S;

struct edge
{
    int v;
    int vis;
    int nxt;
}E[2*1000000+10];

void addEdge(int u,int v)
{
    E[tot].v=v;
    E[tot].vis=0;
    E[tot].nxt=head[u];
    head[u]=tot++;

    E[tot].v=u;
    E[tot].vis=0;
    E[tot].nxt=head[v];
    head[v]=tot++;
}

void tarjan(int u)
{
    dfn[u]=low[u]=++dfs_clock;
    S.push(u);
    for(int i=head[u];i!=-1;i=E[i].nxt)
    {
        int v = E[i].v;
        if(E[i].vis) continue;
        E[i].vis=E[i^1].vis=1;

        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);

            if(low[v]>dfn[u]) bridge++;
        }
        else if(!belong[v])
        {
            low[u]=min(low[u],dfn[v]);
        }
    }

    if(dfn[u]==low[u])
    {
        scc_cnt++;
        for(;;)
        {
            int x = S.top();S.pop();
            belong[x] = scc_cnt;
            if(x==u) break;
        }
    }
}

void init()
{
    memset(head,-1,sizeof(head));
    tot=0;
    memset(dfn,0,sizeof(dfn));
    dfs_clock=0;
    bridge=0;
    memset(belong,0,sizeof(belong));
    scc_cnt=0;
    maxd=0;
    for(int i=1;i<=n;i++) G[i].clear();
    memset(vis,0,sizeof(vis));
}

//找到树的直径
void findMaxDeep(int u,int deep)
{
    vis[u]=1;

    maxd=max(maxd,deep);
    for(int i=0;i<G[u].size();i++)
    {
        int v = G[u][i];
        if(!vis[v])
        {
            findMaxDeep(v,deep+1);
        }
    }
}

//用bfs来找到一个叶子节点
int findRoot()
{
    queue<int> Q;
    Q.push(1);
    vis[1]=1;
    int last=1;
    while(!Q.empty())
    {
        int x = Q.front();Q.pop();
        for(int i=0;i<G[x].size();i++)
        {
            int v = G[x][i];
            if(!vis[v])
            {
                Q.push(v);
                vis[v]=1;
                last=v;
            }
        }
    }
    return last;
}

void solve()
{
    for(int i=1;i<=n;i++) if(!dfn[i]) tarjan(i);

    //重新建图
    for(int i=1;i<=n;i++)
    {
        for(int j=head[i];j!=-1;j=E[j].nxt)
        {
            int v = E[j].v;
            int x = belong[i];
            int y = belong[v];
            if(x!=y)
            {
                G[x].push_back(y);
                G[y].push_back(x);
            }
        }
    }

    int root=findRoot();
    memset(vis,0,sizeof(vis));

    findMaxDeep(root,0);

    printf("%d
",bridge-maxd);
}

int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        if(n==0 && m==0) break;
        init();

        for(int i=1;i<=m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            addEdge(u,v);
        }

        solve();
    }
}

　　但是奇怪的是，重新建图以后找叶子节点的时候，这里用G[x].size()==2不能够实现。讲道理，原理上是没错的，尽管后来发现如果缩点后只有一个点的话是个例外，但是即使排除了这个特殊情况仍然不行，，，这个问题也留着以后探讨吧。。