hdu4612(求树的直径+重边判断)

给出一幅无向图，问加一条边后，最少剩多少个桥。

思路：边双联通分量缩点，求出缩点后的桥个数，最优的加边方法就是在树的直径上加边，所以答案就是缩点后桥的个数，减去树的直径。

这题有重边，两个点的多条边认为是不同的，所以有重边的边一定不是桥，在tarjan的时候就要判断是不是重边了。

求树直径的方法：

任意找一点，bfs找到距离最远的点p，再从p点bfs一次，找到距离最远的点q，p-q就是直径了。

网上的证明：求树的直径算法

1.  证明: 1) 如果u 是直径上的点，则v显然是直径的终点(因为如果v不是的话，则必定存在另一个点w使得u到w的距离更长，则于BFS找到了v矛盾) 
2.                       2) 如果u不是直径上的点，则u到v必然于树的直径相交(反证),那么交点到v 必然就是直径的后半段了 
3.                        所以v一定是直径的一个端点，所以从v进行BFS得到的一定是直径长度

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <stdio.h>
#include <vector>
#include <map>
#include <queue>
#include <string.h>

using namespace std;
const int maxn = 200005;
int dfn[maxn],low[maxn],stack[maxn],color[maxn];
bool vis[maxn];
int dis[maxn];
vector <int> G[maxn];
vector <int> bridge[maxn];
int n, m, cnt, sum, top, tot;

struct node
{
	int u,step;
};
queue <node> Q;

void tarjan(int u,int father)
{
	int flag = 0;
	dfn[u] = low[u] = ++cnt;
	stack[++top] = u;
	int len = G[u].size();
	int v;
	for (int i = 0; i < len; i++)
	{
		v = G[u][i];
		if (!dfn[v])
		{
			tarjan(v,u);
			low[u] = min(low[u],low[v]);
		}
		else if (flag || v!= father)
			low[u] = min(low[u],dfn[v]);
		if (v == father) flag = 1;//这里是判断重，v！= father的目的是去掉回边v->u，当有重边的时候就会有两条以上v->u，第一条当做回边，不做处理，接下来如果还有v->u的边那就一定是重边了。
	}
	if (low[u] == dfn[u])
	{
		++tot;
		++sum;
		do
		{
			v = stack[top--];
			color[v] = sum;
		}while (v != u);
	}
}

void bfs(int u)
{
	while (!Q.empty()) Q.pop();

	node tmp;
	tmp.u = u;
	tmp.step = 0;
	Q.push(tmp);
	vis[u] = true;
	int v;
	node now,next;
	while (!Q.empty())
	{
		now = Q.front();
		Q.pop();
		u = now.u;
		int len = bridge[u].size();
		for (int i = 0; i < len; i++)
		{
			v = bridge[u][i];
			if (!vis[v])
			{
				next.u = v;
				next.step = now.step + 1;
				Q.push(next);
				dis[v] = next.step;
				vis[v] = true;
			}
		}
	}
}

void init()
{
	for (int i = 0; i < maxn; i++)
	{
		G[i].clear();
		bridge[i].clear();
		dfn[i] = 0;
		vis[i] = 0;
		dis[i] = 0;
	}
	tot = cnt = sum = top = 0;
	//mark.clear();
}

int main()
{
	int u, v;
	while (scanf("%d%d",&n,&m) != EOF)
	{
		if (n == 0 && m == 0) break;
		init();
		for (int i = 0; i < m; i++)
		{
			scanf("%d%d",&u,&v);
			G[u].push_back(v);
			G[v].push_back(u);
			//mark[u*n+v]++;
			//mark[v*n+u]++;
		}
		tarjan(1,1);
		for (int u = 1; u <= n; u++)
		{
			int len = G[u].size();
			for (int i = 0; i < len; i++)
			{
				v = G[u][i];
				if (color[u] != color[v])
				{
				//	printf("u = %d v = %d\n",u,v);
					bridge[color[u]].push_back(color[v]);
					bridge[color[v]].push_back(color[u]);
				}
			}
		}
		//printf("tot = %d\n",tot);
		bfs(1);
		int maxdis = 0, k;
		for (int i = 1; i <= sum; i++)
			if (dis[i] > maxdis) {k = i; maxdis = dis[i];}
		memset(vis,0,sizeof(vis));
		bfs(k);
		maxdis = 0;
		for (int i = 1; i <= sum; i++)
			if (dis[i] > maxdis) {k = i; maxdis = dis[i];}
	//	printf("k = %d maxdis = %d\n",k,maxdis);
		printf("%d\n",tot - 1 - maxdis);
	}

	return 0;
}