POJ 3177（Redundant Paths）

题意：求最少加多少条边，使这个图不存在桥；

思路：很明显的边双连通分量的题，首先求出图中的双连通分量，缩点，然后求出度数为1的点的总数，那么答案就是(sum+1)/2；

为什么是(sum+1)/2呢，我的理解是：因为题目说当前图中任意两个顶点最少有一条路相连，那么不同的双连通分量间就只有一条路相连，因为当前u到v有一条路径，所以再给u和v间加多一条边，就可以使这两个点都至少有两条路径到达了。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const int N = 5005;
bool g[N][N], ng[N][N];
int head[N], cnt, n, m, belong[N];
struct Edge{
	int e, next, flag;
}edge[N * 10];

struct Tarjan{	
	int low[N], dfn[N], sta[N * 5];
	int index, top, block;
	void dfs(int u, int pre){
	    int e;
	    low[u] = dfn[u] = ++index;
	    sta[top++] = u;
	    for(int i = head[u];i != -1;i = edge[i].next){
	        e = edge[i].e;
	        if(e == pre)
				continue;
	        if(!dfn[e]){
	            dfs(e, u);
	            low[u] = min(low[u], low[e]);
	        } else if(dfn[e] > 0 && low[u] > dfn[e])
	            low[u] = dfn[e];
	    }
	    if(low[u] == dfn[u]){
	        block++;
	        do{
	            e = sta[--top];
	            belong[e] = block;
	        }while(e != u);
	    }
	}
	int tarjan(){
		top = 0, block = 0, index = 1;
		memset(dfn, 0, sizeof dfn);
		memset(low, 0, sizeof low);
		for(int i = 1;i <= n;i++)
			if(!dfn[i])
				dfs(i, -1);
		return block;
	}
};

void addedge(int a, int b){
	edge[cnt].e = b;
	edge[cnt].next = head[a];
	head[a] = cnt++;
}

void solve(){
	Tarjan bcc;
	int tot = bcc.tarjan(), de[N] = {0};
	memset(ng, false, sizeof ng);
	for(int i = 1;i <= n;i++)
		for(int it = head[i];it != -1;it = edge[it].next){
			int e = edge[it].e, ne = belong[e], ni = belong[i];
			if(ne != ni && !ng[ne][ni] && !ng[ni][ne]){
				ng[ne][ni] = ng[ni][ne] = true;
				de[ne]++, de[ni]++;
			}
		}		
	int res = 0;
	for(int i = 1;i <= tot;i++)
		if(de[i] == 1)
			res++;
	cout << (res + 1) / 2 << endl;
	return ;
}	

int main(){
	while(cin >> n >> m){
		memset(g, false, sizeof g);
		memset(head, -1, sizeof head);
		cnt = 0;	
		for(int i = 0;i < m;i++){
			int a, b;
			scanf("%d%d", &a, &b);
			if(g[a][b] == 1 || g[b][a] == 1)
				continue;
			g[a][b] = g[b][a] = 1;
			addedge(a, b);
			addedge(b, a);
		}
		solve();
	}
	return 0;
}