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;
}