kuangbin专题 专题九 连通图 Warm up HDU - 4612

题目链接：https://vjudge.net/problem/HDU-4612

题目：一个大地图，给定若干个连通图，每个连通图中有若干个桥，你可以在任意某个连通图的

任意两个点添加一条边，问，添加一条边后，大地图中最少剩下几个桥。

思路：tarjan缩点，重构图，对每个新图跑两次dfs求出树的直径，取所有新图的直径max，

答案就是  大地图总桥数 - max(树的直径)。

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <queue>
 #include <vector>
 using namespace std;
 #define pb push_back

 const int N = (int)2e5+;
 const int M = (int)1e6+;
 int n,m,bridge,tot,tim,top,scc;
 int head[N],dfn[N],low[N],s[N],scc_no[N],vis[N];
 struct node{
     int to;
     int nxt;
 }e[M << ];
 vector<int> g[N];//新图
 vector<int> poi;//存单个连通图包含的点

 void init(){
     for(int i = ; i <= n; ++i){
         head[i] = -;
         dfn[i] = ;
         g[i].clear();
     }
     bridge = tot = tim = top = scc = ;
 }

 inline void add(int u,int v){
     e[tot].to = v;
     e[tot].nxt = head[u];
     head[u] = tot++;
 }

 //tarjan缩点
 void tarjan(int now,int pre){
     poi.pb(now);//存下这个连通图包含的点
     dfn[now] = low[now] = ++tim;
     s[top++] = now;
     int to,pre_cnt = ;
     for(int o = head[now]; ~o; o = e[o].nxt){
         to = e[o].to;
         if(to == pre && pre_cnt == ) { pre_cnt = ; continue; }
         if(!dfn[to]){
             tarjan(to,now);
             low[now] = min(low[now],low[to]);
             if(dfn[now] < low[to]) ++bridge;
         }else low[now] = min(low[now],dfn[to]);
     }

     if(dfn[now] == low[now]){
         int x;
         ++scc;
         do{
             x = s[--top];
             scc_no[x] = scc;
         }while(now != x);
     }
 }

 //对poi中的那些点新建一个图
 void rebuild(){
     int to,now;
     for(int i = ; i < (int)poi.size(); ++i){
         now = poi[i];
         for(int o = head[now]; ~o; o = e[o].nxt){
            to = e[o].to;
            if(scc_no[now] == scc_no[to]) continue;
            g[scc_no[now]].pb(scc_no[to]);  g[scc_no[to]].pb(scc_no[now]);
         }
     }
 }

 void dfs(int now,int pre,int deep){
     vis[now] = deep;
     int to;
     for(int i = ; i < (int)g[now].size(); ++i){
         to = g[now][i];
         if(to == pre || to == now || vis[to]) continue;
         dfs(to,now,deep+);
     }
 }

 void test01(){
     for(int i = ; i <= n; ++i)
         printf("%d 属于scc = %d\n",i,scc_no[i]);
 }

 void solve(){

     int max_deep = ,_deep = ;
     int u;
     for(int i = ; i <= n; ++i){
         if(!dfn[i]){
             poi.clear();//清空上个连通图中的点
             tarjan(i,i);
             rebuild();//poi中的点重建图
             dfs(poi[],poi[],);
             _deep = ;
             for(int i = ; i < poi.size(); ++i){
                 if(_deep < vis[poi[i]]){ _deep = vis[poi[i]]; u = poi[i]; }
                 vis[poi[i]] = ; //这里别忘了初始化  不然下次dfs会出错
             }
             dfs(u,u,);
             for(int i = ; i < poi.size(); ++i){
                 _deep = max(_deep,vis[poi[i]]);
                 vis[poi[i]] = ;//这里别忘了初始化  不然下组数据的dfs会出错
             }
             max_deep = max(max_deep,_deep);//对每个连通图跑两次dfs求树的直径，取max
         }
     }
 //    cout << bridge << "   " << max_deep << endl;
     printf("%d\n",bridge - max_deep +);
 }

 int main(){

     int u,v;
     while(~scanf("%d%d",&n,&m) && (n+m)){
         init();
         for(int i = ; i < m; ++i){
             scanf("%d%d",&u,&v);
             add(u,v); add(v,u);
         }
         solve();
     }

     return ;
 }

4 4
1 2
1 3
1 4
2 3

11 12
1 2
1 3
3 2
3 4
4 5
4 6
6 7
7 8
7 9
8 9
8 11
9 10

6 7
1 2
1 3
2 3
3 4
4 5
4 6
5 6

8 6
1 2
1 3
1 4
1 5
7 6
6 8