无向图的边双联通分量，点双联通分量

边双联通分量

参考博客http://blog.csdn.net/lyy289065406/article/details/6762370

直接套用了求割边的模板，所有low值相同的节点都在一个双联通分量里，将双联通分量缩点，

问题再次被转化为至少在缩点树上增加多少条树边，使得这棵树变为一个双连通图”。

首先知道一条等式：

若要使得任意一棵树，在增加若干条边后，变成一个双连通图，那么

至少增加的边数 =（ 这棵树总度数为1的结点数 + 1 ）/ 2。

然后。。

POJ3352 ，POJ3177这两个题是一样的，不过POJ3177是有重边的情况。

直接套用可以处理重边的求割边模板再处理就行了。

求割边模板：http://blog.csdn.net/chaiwenjun000/article/details/51387037

#include<iostream>
#include<cstdio>
#include<vector>
#include<sstream>
#include<cstring>
#include<algorithm>
#define mem(a,x) memset(a,x,sizeof(a))
#define INF 0x3f3f3f3f
using namespace std;
const int N = 5010; // 3352只用1010即可
struct node{
    int v,w,id;
    node(int v = 0,int w = 0,int id = 0):v(v),w(w),id(id){};
};
vector<node>G[N];
int pre[N];
int low[N];
int dfs_num;int ans ;int n,m;
void init(){
    mem(pre,0); mem(low,0);
    for(int i=0;i<=n;i++) G[i].clear();
    dfs_num = 0;ans = INF;
}
int dfs(int u,int fa){
    low[u] = pre[u] = ++dfs_num;
    for(int i=0;i<G[u].size();i++){
        int v = G[u][i].v;
        int id = G[u][i].id;
        if(id == fa) continue;
        if(!pre[v]){
            dfs(v,id);//注意这里 第二个参数是 id
            low[u] = min(low[u],low[v]);//用后代的low更新当前的
        }
        else
            low[u] = min(low[u],pre[v]);//利用后代v的反向边更新low
    }
}
int main(){
    int t;
    while(scanf("%d%d",&n,&m)!=EOF&& (n || m)){
        int a,b,c;
        init();
        for(int i=1;i<=m;i++){
            scanf("%d%d",&a,&b);
            G[a].push_back(node(b,0,i));
            G[b].push_back(node(a,0,i));
        }
        for(int i=1;i<=n;i++){
            if(!pre[i])
                dfs(i,0);
            //cout<<i<<endl;
        }
        int degree[N];mem(degree,0);
        for(int i=1;i<=n;i++){
            for(int j=0;j<G[i].size();j++){
                int v = G[i][j].v;
                if(low[i] != low[v]){
                    degree[low[v]]++; degree[low[i]]++;
                }
            }
        }
        int l = 0;
        for(int i=1;i<=dfs_num;i++)
            if(degree[i] == 2)
            l++;
        printf("%d\n",(l+1)/2);
    }
    return 0;
}

点双联通分量

hdu3394

入门经典训练指南点联通分量模板。

题意：给一个无向图。如果至少有两个环共用了一些边，那么这些边被认为是“冲突边”。如果一些边不在任何一个环中，这些边被认为是“多余边”。你要找出这个图中有多少“多余边”和“冲突边”然后输出条数。另外这图不一定是连通的

 

1.“多余边”不在任何一个环中，那么多余边一定是桥，所以统计这个无向图中有多少桥即可

2.“冲突边”有多少，这个有点费劲，但是不难想到。如果一个环比较特殊，n个点刚好n条边，例如（1,2）（2,3）（1，3）这种环，这个环内，一条“冲突边”都没有，但是如果一个环内的边数大于点数，那么这个环内所有边都是“冲突边”（真可惜，因为有多出来的那些边后，相当于把最外面的大环分割成了内部的几个小环，这些小环和小环之间，小环和大环之间一定会公用一些边，这些边就是“冲突边”，而且可以发现，所有边都会被公用，太可惜了......），例如sample里面的(5,6)(5,4)(6,7)(4,7)(5,7)，相当于最外面的大环<6,5,4,7,6> ， 而里面的边(5,7)把这个大环分割成了两个小环

 

所以做法就是，求出这个无向图有多少个点双连通分量，对于每个点双连通分量，如果内部的边数>点数，那么这些边全部都是冲突边

解析参考http://www.cnblogs.com/scau20110726/archive/2013/05/19/3087815.html

#include<cstring>
#include<iostream>
#include<cstdio>
#include<vector>
#include<stack>
#include<algorithm>
#define mem(a,x) memset(a,x,sizeof(a))
typedef long long ll;
using namespace std;
const int N = 10010;
//割点的bccno无意义
struct Edge{
    int u,v;
};
int pre[N],bccno[N],iscut[N],low[N],dfs_num,cnt;

vector<int>G[N],bcc[N];
stack<Edge>S;
int n,m,bridge,res;
void init(){
    mem(pre,0); mem(bccno,0);mem(iscut,0);
    mem(low,0);
    dfs_num = cnt = bridge = res = 0;
    for(int i=0;i<=n;i++)
        G[i].clear();
    while(!S.empty())S.pop();

}
void func(int x){
    bool inbcc[n]; mem(inbcc,0);
    for(int i=0;i<bcc[x].size();i++)
        inbcc[bcc[x][i]] = 1;
    int edge = 0;
    for(int i=0;i<bcc[x].size();i++){
        int u = bcc[x][i];
        for(int j=0;j<G[u].size();j++)
            if(inbcc[G[u][j]])
                edge++;
    }
    edge/=2; //双向建图，需要除2
    if(edge > bcc[x].size()) //边大于点
        res += edge;
}
int dfs(int u,int fa){
    low[u] = pre[u] = ++ dfs_num;
    int child = 0;
    for(int i=0;i<G[u].size();i++){
        int v = G[u][i];
        Edge e = (Edge){u,v};
        if(!pre[v]){
            S.push(e); child++;
            dfs(v,u);
            low[u] = min(low[u],low[v]);
            if(low[v] > pre[u])
                bridge++;
            if(low[v] >= pre[u]){
                iscut[u] = true;
                cnt++; bcc[cnt].clear();
                while(1){
                    Edge x = S.top();S.pop();
                    if(bccno[x.u] != cnt){
                        bcc[cnt].push_back(x.u);
                        bccno[x.u] = cnt;
                    }
                    if(bccno[x.v] != cnt){
                        bcc[cnt].push_back(x.v);
                        bccno[x.v] = cnt;
                    }
                    if(x.u == u && x.v == v) break;
                }
                func(cnt);
            }
        }
        else if(pre[v] < pre[u] && v != fa){
                S.push(e);
                low[u] = min(low[u],pre[v]);
        }
    }
    if(fa < 0 && child == 1) iscut[u] = 0;
}
int main(){

    while(scanf("%d%d",&n,&m) ,n + m){
        init();
        int a,b;
        for(int i=0;i<m;i++){
            scanf("%d%d",&a,&b);
            G[a].push_back(b);
            G[b].push_back(a);
        }
        for(int i=0;i<n;i++)
            if(!pre[i]) dfs(i,-1);
        //printf("%d\n",cnt);

        printf("%d %d\n",bridge,res);
    }
    return 0;
}