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 = +;
 
 int n,m,dfn[N],low[N];
 int head[N];
 int tot=;
 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[*+];
 
 void addEdge(int u,int v)
 {
     E[tot].v=v;
     E[tot].vis=;
     E[tot].nxt=head[u];
     head[u]=tot++;
 
     E[tot].v=u;
     E[tot].vis=;
     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!=-;i=E[i].nxt)
     {
         int v = E[i].v;
         if(E[i].vis) continue;
         E[i].vis=E[i^].vis=;
 
         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,-,sizeof(head));
     tot=;
     memset(dfn,,sizeof(dfn));
     dfs_clock=;
     bridge=;
     memset(belong,,sizeof(belong));
     scc_cnt=;
     maxd=;
     for(int i=;i<=n;i++) G[i].clear();
     memset(vis,,sizeof(vis));
 }
 
 //找到树的直径
 void findMaxDeep(int u,int deep)
 {
     vis[u]=;
 
     maxd=max(maxd,deep);
     for(int i=;i<G[u].size();i++)
     {
         int v = G[u][i];
         if(!vis[v])
         {
             findMaxDeep(v,deep+);
         }
     }
 }
 
 //用bfs来找到一个叶子节点
 int findRoot()
 {
     queue<int> Q;
     Q.push();
     vis[]=;
     int last=;
     while(!Q.empty())
     {
         int x = Q.front();Q.pop();
         for(int i=;i<G[x].size();i++)
         {
             int v = G[x][i];
             if(!vis[v])
             {
                 Q.push(v);
                 vis[v]=;
                 last=v;
             }
         }
     }
     return last;
 }
 
 void solve()
 {
     for(int i=;i<=n;i++) if(!dfn[i]) tarjan(i);
 
     //重新建图
     for(int i=;i<=n;i++)
     {
         for(int j=head[i];j!=-;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,,sizeof(vis));
 
     findMaxDeep(root,);
 
     printf("%d\n",bridge-maxd);
 }
 
 int main()
 {
     while(scanf("%d%d",&n,&m)==)
     {
         if(n== && m==) break;
         init();
 
         for(int i=;i<=m;i++)
         {
             int u,v;
             scanf("%d%d",&u,&v);
             addEdge(u,v);
         }
 
         solve();
     }
 }

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