poj 3177  有点难度的边-双连通

题意：题目给出一个连通图 ， 问把这个图变成边-双连通图 ， 最少需要添加多少条边？

解法：有边-双连通分量的特点我们知道 ， 每个点只属于一个边-双连通分量（这里桥不属于边-双连通分量） ， 因此我们把每个边-双连通分量缩成一个点 ， 并且把桥记录下来 ， 那么我们就能得到有所有桥组成的一个图 ， 并且这个图是连通的 ， 没有环的， 那么我们的目的就把把这个图变成一个边-双连通图 ， 我们就只需要知道度为 1 的点有多少个 ， 假设为 x ， 那么答案就是 (x+1)/2

代码：


#include
#include
#include
#include
using namespace std;

#define maxn 10010
#define min(x , y)  (x)<(y)?(x):(y)
#define max(x , y)  (x)>(y)?(x):(y)
int low[maxn] , pre[maxn] , is_cnt[maxn] , sum;
int n , dfs_clock , m , edge_sum;

struct node
{
      int u ;
      int next;
      bool select;
      int x;
}edge[200010];

int head[maxn];
int p[maxn] , grap[maxn][2];

void init()
{
      memset(head , -1, sizeof(head));
      memset(pre , 0 , sizeof(pre));
      //memset(is_cnt , 0 , sizeof(is_cnt));
      for(int i = 1; i <= n; i++)
            p[i] = i;
      dfs_clock = 0;
      sum = 0;
      edge_sum = 0;
}

int find(int x)
{
      int g = x , h;
      while(x != p[x])  x = p[x];

      while(p[g] != x)
      {
            h = p[g];
            p[g] = x;
            g = h;
      }

      return x;
}

void Union(int x , int y)
{
      int g = find(x) , h = find(y);
      if(g != h)  p[g] = h;
}

int dfs(int u)
{
//      cout<<u<<endl;
      int lowu = low[u] = ++dfs_clock;
      int i , lowv , child = 0;
      for(i = head[u] ; i != -1; i = edge[i].next)
      {
            int v = edge[i].u;
            if(!edge[i].select)
            {
                  edge[i].select = true;//这里就能判断重边
                  edge[i^1].select = true;
                  if(!pre[v])
                  {
                       
                        child += 1;
                        pre[v] = 1;
                        lowv = dfs(v);
                       
                        lowu = min(lowu , lowv);
                        if(lowv > low[u])
                              grap[edge_sum][0] = u , grap[edge_sum++][1] = v;
                        else
                              Union(u , v); //这两个点肯定是属于同一个边-双连通分量 ， 我们就用并查集把它标记
                  }
                  else lowu = min(lowu , low[v]);
            }
      }
//      if(low[u] == 1 && child <= 1)  is_cnt[u] = 0;
      return lowu;
}

int find_doubleconnection()
{
      pre[1] = 1;
      dfs(1);
      memset(pre , -1 , sizeof(pre)); //记录原图中每个点在新图中是哪个点
      int i , xy = 1 , k;

      for(i = 1; i <= n; i++)
      {
            k = find(i);
            if(pre[k] == -1)  pre[k] = xy++;
            pre[i] = pre[k];
      }

      return xy;
}

int main()
{
      int t;
//      cin>>t;
      while(scanf("%d %d" , &n , &m) != EOF)
      {
            init();
           
            int i , x , y , k = 0;
            for(i = 0; i < m; i++)
            {
                  scanf("%d %d" , &x , &y);
                  edge[k].u = y;
                  edge[k].next = head[x];
                  edge[k].x = i+1;
                  edge[k++].select = false;
                  head[x] = k-1;

                  edge[k].u = x;
                  edge[k].next = head[y];
                  edge[k].x = i+1;
                  edge[k++].select = false;
                  head[y] = k-1;
                 
            }
           
            int ans = find_doubleconnection();

            memset(low , 0 , sizeof(low)); //记录新图中每个点的度数
            for(i = 0; i < edge_sum ; i++)
            {
                  x = pre[grap[i][0]] , y = pre[grap[i][1]];
                  low[x] += 1;
                  low[y] += 1;
            }
           
            x = 0;
            for(i = 1; i < ans; i++)
                  if(low[i] == 1)  x += 1;
            //cout<<x<<endl;
            x = (x+1)/2;
            cout<<x<<endl;

           
      }
      return 0;
}