USACO Training Section 2.4 Cow Tours

[url="http://ace.delos.com/usacoprob2?a=nNDUxS4hI8l&S=cowtour"]英文原题[/url] [url="http://www.wzoi.org/usaco/main.asp?dir=13&wenjian=404"]中文题译[/url]

大意：在平面上有N个点，若干条直线边连接其中部分点，使得其构成至少两个连通片。现要增加一条连接两个不同连通片的边，使得新的连图片的周长最小。

最初的想法如下：
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
这里至少包含两个基本算法，求连通片和周长。如果对每条边做枚举来计算新连通片的周长，复杂度是O(n^4)显然是不可接受的。所以一定要做优化处理。

不难证明，对两个连通片G1,G2，增加所有顶点分别在G1和G2中的边所得的周长与增加一条边所得到的最小周长是相同的。从而，不需对所有边做枚举，而只需对不同连通片对做遍历即可。

求连通片，用dfs在O(n^2)时间内可以从矩阵邻接表中得到。记录下每个连通片的顶点备用。

为减少计算量，每个顶对之间的距离只计算一次，所以可以在一开始就把距离单独存为一个矩阵计算出来。若需要减少计算量，则可以考虑只计算连接不同连通片的边和原始存在的边的长度。不过，没有必要为这个增加编程复杂度。注意，边长需要用double来表示。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

实现之后发现所求解不对，仔细一想，之前的"不难证明"是个想当然的结论，是错误的。哎，晕。之后顺手写了个暴力算的，结果，不难预料，超时了。于是重新考虑，大骂自己是笨蛋。

事实上，任意加入一条连接两个连通片C1,C2的边e之后，顶点对分为三类：均在C1中，均在C2中，或一个在C1中一个在C2中。前两者的距离的最大值是C1，C2的周长，最后这类边均经过e=(v1,v2)，设v1在C1中，v2在C2中，则此类边的最大长度为C1中的顶点到v1的最大距离＋e的长度＋C2中的顶点到v2的最大距离。而这两个最大距离，在用Floyd-Warshall算法求周长时，就已经得到了，只需存下来即可。因此，判断加边之后的周长的可在O(n^2)时间内完成。

最后通过时间，最长0.043秒。

教训：千万不要想当然。唉。

编程上的改进：可以直接用整个矩阵做Floyd-Warshall算法，不需要区分连通片。在程序上简单些。

/*
ID: blackco3
TASK: cowtour
LANG: C++
*/
#include <iostream>
#include <math.h>
#include <memory.h>
using namespace std;
#define _max_node_ 150
int n_node, x[_max_node_], y[_max_node_] ;
double map[_max_node_][_max_node_] ;
char conn[_max_node_][_max_node_+1] ;

inline double dis( int i, int j ){
	return sqrt( ((double)(x[i]-x[j]))*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]) );
}

int grps[_max_node_][_max_node_], grp_size[_max_node_], n_grp=0, grp_id[_max_node_] ;
void get_group(int node ) {
	int stk[_max_node_], *top=stk, vis[_max_node_] ;
	memset( vis, 0, sizeof(int)*n_node );
	grp_size[n_grp]=0, grps[n_grp][grp_size[n_grp]++]=node, grp_id[node]=n_grp;
	*(top++)=node, vis[node]=1 ;
	do{
		register int cn=*(--top);
		for( int i=0; i<n_node; i++ )
			if( conn[cn][i]=='1' && !vis[i] )
				*(top++)=i , vis[i]=1, grps[n_grp][ grp_size[n_grp]++ ]=i, grp_id[i]=n_grp ;
	}while(top!=stk);
	n_grp++ ;
}

double longest[_max_node_], grp_dim[_max_node_] ;
void get_grp_dim( int grp_id ) {
	register int m_size=grp_size[grp_id] ;
	for( int k=0; k<m_size; k++ ){
		register int kid=grps[grp_id][k];
		for( int i=0; i<m_size; i++ ) {
			register int iid=grps[grp_id][i];
			if( map[iid][kid]<0 )
				continue ;
			for( int j=0; j<m_size; j++) {
				register int jid=grps[grp_id][j];
				if( map[kid][jid]<0 )
					continue ;
				if( map[iid][jid]<0 || map[iid][kid] + map[kid][jid] < map[iid][jid] )
					map[iid][jid] = map[iid][kid] + map[kid][jid];
			}
		}
	}
	double dim=-1;
	for( int i=0; i<m_size; i++ ) {
		double cur_max=0 ;
		for( int j=0; j<m_size; j++ )
			if( i!=j )
				cur_max = max( cur_max, map[grps[grp_id][i]][grps[grp_id][j]] ) ;
		longest[grps[grp_id][i]] = cur_max ;
		dim = max( dim, cur_max ) ;
	}
	for( int i=0; i<m_size; i++ ) 
		grp_dim[grps[grp_id][i]] = dim ;
}

int main() {
	freopen("cowtour.in", "r", stdin);
	freopen("cowtour.out", "w", stdout);
	cin >> n_node ;
	for( int i=0; i<n_node; i++ )
		cin >> x[i] >> y[i] ;
	for( int i=0; i<n_node; i++ )
		cin >> conn[i] ;
	for( int i=0; i<n_node; i++ )
		for( int j=i; j<n_node; j++ )
			map[i][j] = map[j][i] = conn[i][j]=='1' ?  dis(i,j): -1;

	memset( grp_id, 0xff, sizeof(grp_id) );
	for( int i=0; i<n_node; i++ )
		if( grp_id[i]==-1 )
			get_group(i);
	for( int i=0; i<n_grp; i++ )
		get_grp_dim( i );

	double min_dim=-1;
	for( int i=0; i<n_node; i++ )
		for( int j=i+1; j<n_node; j++ ){
			if( grp_id[i]==grp_id[j] ) 
				continue ;
			double cur_dim = max( dis(i,j)+longest[i]+longest[j] , max( grp_dim[i], grp_dim[j] ) );
			min_dim = min_dim==-1 || cur_dim<min_dim ? cur_dim : min_dim ;
		}
	printf("%.6lf\n", min_dim);		

	return 0;
}