HDU4612 Warm up 边双连通分量&&桥&&树直径

题目的意思很简单，给你一个已经连通的无向图，我们知道，图上不同的边连通分量之间有一定数量的桥，题目要求的就是要你再在这个图上加一条边，使得图的桥数目减到最少。

首先要做的就是找出桥，以及每个点所各自代表的连通分量。 找桥的方法就是经典的low[u],pre[v]的判断，这个在大白书上也有比较详尽的介绍。当我们找到桥之后我们当然要把桥边存起来，存的时候就有很多姿势了，因为题目给的点达到200000的级别，所以肯定不能开一个邻接矩阵，所以存的时候要么就开个vector<Edge>存下所有的桥边，但是遍历索引的时候就会很蛋疼。要么就采用另外一种方法，vector<int> P[i],其中P[i]这个vector里存下了所有的与i相连构成桥边的点，也就是P[i][j]和i之间存在桥。

找完桥之后就是找边双连通分量。按照大白书上的说法，第一遍dfs找桥，第二遍dfs只需要跳过所有的桥边dfs就可以找到属于同一个边双连通分量的点了。所以当你要判断由u能不能dfs到v的时候，只需要判断(u,v) 是不是桥，也就是v在不在P[i]里，在的话则跳过。

当我们做完上述操作的时候，我们就可以求出了各自点代表的连通分量了。这个时候我们就重新缩点构图，处于同一个边双连通分量内的点缩成一个点，那么最后什么边会是新图上的边呢？ 根据性质我们可以知道，只有桥才是新图上的边，这个时候我们存储的P[i]就派上大用途了，因为P[i][j]和i各自处于的双连通分量中存在边，所以根据P数组和bccno就可以建出新的图。

建出新的图之后就是关于如何实现减少桥边的问题了。不难发现，当前的图是一棵树（这是自然的吧），所以树上的每一条边都是桥，当我们加了一条边之后，就会形成环，这个环所在的所有点这时候又缩成一个点，换言之，环上的桥边减少了。显然我们要选的就是新图上最长的链。

树的最长链就是树的直径。找直径的方法可以考虑采取树dp（我之前的挫办法），也可以用两次BFS,随便选一个点BFS,BFS到的最后一个点一定是直径的一端，然后再从这个点BFS,BFS到的最后一个点必然也是直径的一端。但是BFS写起来没有DFS版本的快，DFS就是随便选一点dfs,dfs到的深度最大的点是直径的一端，从那一个点再dfs一次，深度最大的那个点就是直径的另一端，这时这个点的深度dep-1就是最长链的长度。

最后输出的答案就是桥的数量－最长链的长度，桥的数量就是树的点－1 也就是 bcc_cnt-1, 最长链的长度是dep-1,所以最后的答案就是bcc_cnt-dep

下面的代码严重的参(chao)考(xi)了这个网址，感谢大神们的博客让我得到长足的进步：

http://www.cnblogs.com/arbitrary/archive/2013/08/04/3236092.html

#pragma warning(disable:4996)
#pragma comment(linker,"/STACK:102400000,102400000")
#include<cstring>
#include<string>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cmath>
#include<iostream>
#define maxn 200050
using namespace std;

struct Edge
{
	int u, v;
	Edge(){}
	Edge(int ui, int vi) :u(ui), v(vi){}
};

vector<int> G[maxn+50];
vector<Edge> edges;
vector<int> P[maxn + 50]; // 桥点邻接表
int n,m;

int low[maxn + 50];
int pre[maxn + 50];
int dfs_clock;

int dfs(int u, int fa)
{
	int lowu = pre[u] = ++dfs_clock;
	for (int i = 0; i < G[u].size(); i++){
		int mm = G[u][i];
		if (fa == (mm ^ 1)) continue;
		int v = edges[mm].v;
		if (!pre[v]){
			int lowv = dfs(v, mm);
			lowu = min(lowu, lowv);
			if (lowv>pre[u]){
				P[u].push_back(v);
				P[v].push_back(u);
			}
		}
		else if (pre[v] < pre[u]){
			lowu = min(lowu, pre[v]);
		}
	}
	return low[u] = lowu;
}

int bccno[maxn + 50];
int bcc_cnt;
void dfs_bcc(int u)
{
	bccno[u] = bcc_cnt;
	for (int i = 0; i < G[u].size(); i++){
		int mm = G[u][i];
		int v = edges[mm].v;
		if (bccno[v]) continue;
		bool flag = true;
		for (int j = 0; j < P[u].size(); j++){
			if (v == P[u][j]) {
				flag = false;
				break;
			}
		}
		if (!flag) continue;
		dfs_bcc(v);
	}
}

void find_bcc()
{
	memset(low, 0, sizeof(low));
	memset(pre, 0, sizeof(pre));
	dfs_clock = 0;
	memset(bccno, 0, sizeof(bccno));
	bcc_cnt = 0;
	for (int i = 1; i <= n; i++){
		if (!pre[i]) dfs(i, -1);
	}
	for (int i = 1; i <= n; i++){
		if (!bccno[i]){
			bcc_cnt++;
			dfs_bcc(i);
		}
	}
}

vector<int> NG[maxn + 50];
int dep[maxn + 50];
void ndfs(int u, int depth)
{
	dep[u] = depth;
	for (int i = 0; i < NG[u].size(); i++){
		int v = NG[u][i];
		if (!dep[v]) ndfs(v, depth + 1);
	}
}

void constructNG()
{
	for (int i = 0; i <= bcc_cnt; i++){
		NG[i].clear();
	}
	for (int i = 1; i <= n; i++){
		for (int j = 0; j < P[i].size(); j++){
			int v = P[i][j];
			NG[bccno[i]].push_back(bccno[v]);
		}
	}
}

int main()
{
	while (cin >> n >> m&&(n||m))
	{
		for (int i = 0; i <= n; i++) G[i].clear(), P[i].clear();
		edges.clear();
		int u, v;
		for (int i = 0; i < m; i++){
			scanf("%d%d", &u, &v);
			edges.push_back(Edge(u, v));
			G[u].push_back(edges.size() - 1);
			edges.push_back(Edge(v, u));
			G[v].push_back(edges.size() - 1);
		}
		find_bcc();
		constructNG();
		memset(dep, 0, sizeof(dep));
		ndfs(1, 1);
		int mxdep = 0; int mdp=0;
		for (int i = 1; i <= bcc_cnt; i++){
			if (dep[i] > mxdep){
				mdp = i; mxdep = dep[i];
			}
		}
		memset(dep, 0, sizeof(dep));
		ndfs(mdp, 1);
		mxdep = 0;
		for (int i = 1; i <= bcc_cnt; i++){
			if (dep[i] > mxdep) mxdep = dep[i];
		}
		printf("%d\n", bcc_cnt-mxdep);
	}
	return 0;
}