***************************************转载请注明出处：http://blog.csdn.net/lttree********************************************
这道课程设计，费不少时间，太麻烦了= =。（明明是能力不够
~~~~最小生成树：室内布线~~~~
题目要求：
装修新房子是一项颇为复杂的project，如今须要写个程序帮助房主设计室内电线的布局。
首先，墙壁上插座的位置是固定的。插座间须要有电线相连，并且要布置的整齐美观，即要求每条线都与至少一条墙边平行，且嵌入四壁或者地板（不能走屋顶）。
房主要求知道，要将全部插座连通，自己须要买的电线的最短长度。
另外，别忘了每一个房间都有门，电线不能够穿门而过。上图给出了一个有4插座的房间的电线布局。
输入要求：
输入由若干组測试数据组成。
每组数据的第1行包括房间的长、宽、高和插座的个数N（N为一个不超过20的正整数）。
接下去的N行中，第i行给出第i个插座的位置坐标（xi,yi,zi）；最后一行包括4个3元组（x1,y1,z1）…（x4，y4，z4），各自是长方形门框的4个角三维坐标。4个数字所有为0表示所有測试结束，不要对该数据不论什么处理。
注意：这里如果长方体形状的房间全然位于三维直角坐标系的第一象限内，而且有一个角落在原点上。地板位于x-y平面。题目数据保证，每一个插座仅属于四面墙中的一面，门上没有插座。要求每段电线的两端必须仅与插座连接，电线之间不能互相交叉焊接。
输出要求：
对每一组測试，在一行里输出要将全部插座连通须要买的电线的最短整数长度。
输入样例：
10 10 10 4
0 1 3.3
2.5 0 2
5 0 0.8
5 10 1
0 0 0 0 0 3 1.5 0 0 1.5 0 3
0 0 0 0
输出样例：
21
这道题，注意下面几点：
① 布线要与墙平行
② 两插座位置关系
③ 线能够走地面，不能够走屋顶和门
④ 最后数据，向上取整
然后，题目考查的是最小生成树，但我花了非常多时间求两插座之间的距离= =。。
我代码凝视中出现的 1,2,3,4 4个面为：正对着我们的为 1号面，我们正对着1号面，它的左面为2号面，1号面右面为3号面，1号面相对着4号面。
然后，程序是：
/*******************************************
********************************************
* Author:Tree *
* From : blog.csdn.net/lttree *
* Title : 最小生成树：室内布线 *
* Source: 数据结构_课程设计 *
* Hint : 最小生成树 *
********************************************
*******************************************/
#include <iostream>
#include <algorithm>
#include <math.h>
using namespace std;
/****** 一些相关变量的定义 ******/
// 插座个数，最多为20个，所以，边最多仅仅有400个
#define MAX 401
// 点的结构体
struct Node
{
double x,y,z;
}nd[21],door[4];
// 含权值的边的结构体
struct Edge
{
int u;
int v;
double quan;
}eg[MAX];
// N - 插座个数，len,wid,hei - 房间的长、宽、高，pos_door门所在位置
int N,len,wid,hei,pos_door;
int father[21];
/****** 推断两插座位置关系 ******/
// 是否在同一墙面
bool isTogether( Node a , Node b )
{
if( (a.x==b.x && (a.x==0||a.x==len) ) || (a.y==b.y && (a.y==0||a.y==wid) ) ) return true;
return false;
}
// 推断是否在相邻墙面
bool isBeside( Node a , Node b )
{
if( a.x==0 || a.x==len )
{
if( b.y==0 || b.y==wid )
return true;
else
return false;
}
else if( a.y==0 || a.y==wid )
{
if( b.x==0 || b.x==len )
return true;
else
return false;
}
}
// 是否在相对墙面
bool isAcross( Node a , Node b )
{
if( (a.x==0 && b.x==len) || (a.y==0 && b.y==wid) || (a.x==len && b.x==0) || (a.y==wid && b.y==0) )
return true;
else
return false;
}
/****** 一系列推断 ******/
// 求最小值
double Min( double a,double b)
{
return a<b?a:b;
}
// 推断门在哪个墙面
int judge_d( Node d[] )
{
if( d[0].y==0 && d[3].y==0 ) return 1;
else if( d[0].x==0 && d[3].x==0 ) return 2;
else if( d[0].x==len && d[3].x==len ) return 3;
else if( d[0].y==wid && d[3].y==wid ) return 4;
}
// 推断两个同墙插座间连线是否穿门
bool judge_crossdoor( Node n1, Node n2 )
{
// 假设插座在最以下，或者插座位置高于门的位置，则不穿过门（不管墙和插座位置关系怎样）
if( n1.z==0 || n2.z==0 || n1.z>=door[3].z || n2.z>=door[3].z ) return false;
if( pos_door==1 )
{
if( n1.y!=0 && n2.y!=0 ) return false;
if( (n1.x>=door[3].x && n2.x>=door[3].x) || (n1.x<=door[0].x && n2.x<=door[0].x) ) return false;
return true;
}
else if( pos_door==2 )
{
if( n1.x!=0 && n2.x!=0 ) return false;
if( (n1.y<=door[0].y && n2.y<=door[0].y) || (n1.y>=door[3].y && n2.y>=door[3].y) ) return false;
return true;
}
else if( pos_door==3 )
{
if( n1.x!=len && n2.y!=len ) return false;
if( (n1.y<=door[0].y && n2.y<=door[0].y) || (n1.y>=door[3].y && n2.y>=door[3].y) ) return false;
return true;
}
else
{
if( n1.y!=wid && n2.y!=wid ) return false;
if( (n1.x>=door[3].x && n2.x>=door[3].x) || (n1.x<=door[0].x && n2.x<=door[0].x) ) return false;
return true;
}
}
/****** 求布线长度 ******/
// 求同墙两插座最短布线
double find_togcost( Node a,Node b )
{
// 两插座同墙且不穿门
if( !judge_crossdoor( a , b ) )
return (fabs(a.x-b.x)+fabs(a.y-b.y)+fabs(a.z-b.z));
else
{
// 两插座布线会穿过门，门的位置不同
if( pos_door==1 || pos_door==4 ) return Min( (fabs(a.x-b.x)+fabs(door[3].z-a.z)+fabs(door[3].z-b.z) ),(fabs(a.x-b.x)+a.z+b.z) );
else return Min( (fabs(a.y-b.y)+fabs(door[3].z-a.z)+fabs(door[3].z-b.z)),(fabs(a.y-b.y)+a.z+b.z) );
}
}
// 求相对墙两插座最短布线
double find_acrcost( Node a,Node b )
{
double cost1,cost2;
Node temp1,temp2;
// 插座在1,4面
if( (a.y==0 && b.y==wid) || (b.y==0 && a.y==wid) )
{
// 依据门的位置，求权值
if( pos_door==1 ) return Min( Min( (a.y+fabs(door[3].z-a.z)+len+b.y),(a.y+a.z+len+b.y) ),Min( (wid-a.y+len+wid-b.y),(a.z+len+b.z) ) );
else if( pos_door==2 )
{
temp1=temp2=a;
temp1.y=0,temp2.y=wid;
cost1=find_togcost(a,temp1);
cost2=find_togcost(a,temp2);
return Min( (cost1+len+b.y),(cost2+len+wid-b.y) );
}
else if( pos_door==3 )
{
temp1=temp2=b;
temp1.y=0,temp2.y=wid;
cost1=find_togcost(b,temp1);
cost2=find_togcost(b,temp2);
return Min( (cost1+len+a.y),(cost2+len+wid-a.y) );
}
else return Min( Min( (a.y+len+b.y),(wid-a.y+wid-b.y+fabs(door[3].z-a.z)+len) ), Min( (wid-a.y+wid-b.y+a.z+len),(a.z+b.z+len) ) );
}
else
{
if( pos_door==1 )
{
temp1=temp2=a;
temp1.x=0,temp2.x=len;
cost1=find_togcost(a,temp1);
cost2=find_togcost(a,temp2);
return Min( (cost1+wid+b.x),(cost2+wid+len-b.x) );
}
else if( pos_door==2 ) return Min( Min( (a.x+b.x+wid+fabs(door[3].z-a.z)),(a.x+b.x+wid+a.z) ),Min( (len-a.x+len-b.x+wid),(a.z+b.z+wid) ) );
else if( pos_door==4 )
{
temp1=temp2=b;
temp1.x=0,temp2.x=len;
cost1=find_togcost(b,temp1);
cost2=find_togcost(b,temp2);
return Min( (cost1+wid+a.x),(cost2+wid+len-a.x) );
}
else return Min( Min( (a.x+b.x+wid),(a.z+b.z+wid) ),Min( (len-a.x+len-b.x+fabs(door[3].z-a.z)+wid),(len-a.x+len-b.x+a.z+wid) ) );
}
}
// 求相邻墙两插座最短布线
double find_bescost( Node a , Node b )
{
Node temp=a;
// 在两平面连接处找一个点（让当中一点x,y为0就可以），转化为两个 同墙插座 问题
if( (a.x==0 && b.y==0) || (b.x==0 && a.y==0) )
{
temp.x=temp.y=0;
return ( find_togcost(a,temp)+find_togcost(b,temp) );
}
else if( (a.x==len && b.y==0) || (a.y==0 && b.x==len) )
{
temp.x=len,temp.y=0;
return ( find_togcost(a,temp)+find_togcost(b,temp) );
}
else if( (a.x==0 && b.y==wid) || (b.x==0 && a.y==wid) )
{
temp.x=0,temp.y=wid;
return ( find_togcost(a,temp)+find_togcost(b,temp) );
}
else
{
temp.x=len,temp.y=wid;
return ( find_togcost(a,temp)+find_togcost(b,temp) );
}
}
/****** 求最小生成树(Kruscal) ******/
// 比較函数
bool cmp(Edge e1,Edge e2)
{
return e1.quan<e2.quan;
}
// 并查集 初始化函数
void Init( int m )
{
int i;
for(i=1;i<=m;i++)
father[i]=i;
}
// 并查集 查找函数
int Find(int x)
{
while(father[x]!=x)
x=father[x];
return x;
}
// 并查集 合并函数
void Combine(int a,int b)
{
int temp_a,temp_b;
temp_a=Find(a);
temp_b=Find(b);
if(temp_a!=temp_b)
father[temp_a]=temp_b;
}
// 最小生成树 Kruskal 算法
double Kruskal( int n )
{
Edge e;
int i;
double res;
sort(eg,eg+n,cmp);
// 并查集 初始化
Init(N);
// 构建最小生成树
res=0;
for( i=0;i<n;++i )
{
e=eg[i];
if( Find(e.u)!=Find(e.v) )
{
Combine(e.u,e.v);
res+=e.quan;
}
}
return res;
}
/****** 主函数 ******/
void main()
{
// i,j 为中间变量，k为边的个数
int i,j,k;
while( cin>>len>>wid>>hei>>N )
{
// 输入数据为4个0，则退出程序
if( !len && !wid && !hei && !N ) break;
// 获取数据（插座与门的位置）
for( i=0 ; i<N ; ++i )
cin>>nd[i].x>>nd[i].y>>nd[i].z;
for( i=0 ; i<4 ; ++i )
cin>>door[i].x>>door[i].y>>door[i].z;
pos_door=judge_d( door );
/* 求两点间距离（注意，布线要与墙平行） */
k=0;
for( i=0 ; i<N ; ++i )
{
for( j=i+1; j<N ; ++j )
{
eg[k].u=i;
eg[k].v=j;
// 推断两点关系，同墙or相邻墙or相对墙
// 同墙
if( isTogether( nd[i] , nd[j] ) ) eg[k].quan=find_togcost(nd[i],nd[j]);
// 相对墙
else if( isAcross( nd[i] , nd[j] ) ) eg[k].quan=find_acrcost(nd[i],nd[j]);
// 相邻墙
else eg[k].quan=find_bescost(nd[i],nd[j]);
++k;
}
}
/* 用Kruscal算法求最小生成树 */
// 注意最后，不管长度怎样，都要向上取整
double cost;
cost=Kruskal(k);
if( cost-int(cost)==0 ) cout<<cost<<endl;
else cout<<int(cost+1)<<endl;
}
}
***************************************转载请注明出处：http://blog.csdn.net/lttree********************************************