openjudge 距离排序

题目题目：

1:距离排序
查看 提交 统计 提问
总时间限制: 1000ms 内存限制: 65536kB
描述
给出三维空间中的n个点（不超过10个）,求出n个点两两之间的距离,并按距离由大到小依次输出两个点的坐标及它们之间的距离。
输入
输入包括两行，第一行包含一个整数n表示点的个数，第二行包含每个点的坐标(坐标都是整数)。点的坐标的范围是0到100，输入数据中不存在坐标相同的点。
输出
对于大小为n的输入数据，输出n*(n-1)/2行格式如下的距离信息：
(x1,y1,z1)-(x2,y2,z2)=距离
其中距离保留到数点后面2位。
(用cout输出时保留到小数点后2位的方法:cout<<fixed<<setprecision(2)<<x)
样例输入
4
0 0 0 1 0 0 1 1 0 1 1 1
样例输出
(0,0,0)-(1,1,1)=1.73
(0,0,0)-(1,1,0)=1.41
(1,0,0)-(1,1,1)=1.41
(0,0,0)-(1,0,0)=1.00
(1,0,0)-(1,1,0)=1.00
(1,1,0)-(1,1,1)=1.00
提示
用cout输出时保留到小数点后2位的方法:cout<<fixed<<setprecision(2)<<x

注意：
冒泡排序满足下面的性质,选择排序和快速排序(qsort或sort)需要对下面的情况进行额外处理
使用冒泡排序时要注意边界情况的处理,保证比较的两个数都在数组范围内

1. 对于一行输出中的两个点(x1,y1,z1)和(x2,y2,z2)，点(x1,y1,z1)在输入数据中应出现在点(x2,y2,z2)的前面。

比如输入：
2
0 0 0 1 1 1
输出是：
(0,0,0)-(1,1,1)=1.73
但是如果输入：
2
1 1 1 0 0 0
输出应该是：
(1,1,1)-(0,0,0)=1.73

2. 如果有两对点p1,p2和p3,p4的距离相同，则先输出在输入数据中靠前的点对。

比如输入：
3
0 0 0 0 0 1 0 0 2
输出是：
(0,0,0)-(0,0,2)=2.00
(0,0,0)-(0,0,1)=1.00
(0,0,1)-(0,0,2)=1.00
如果输入变成：
3
0 0 2 0 0 1 0 0 0
则输出应该是：
(0,0,2)-(0,0,0)=2.00
(0,0,2)-(0,0,1)=1.00
(0,0,1)-(0,0,0)=1.00

===================================================================

冒泡排序。关于冒泡排序，已知如下几点：

1. 交换排序的一种，还有一种更为著名的交换排序是快速排序。
2. 冒泡排序是稳定的，即，关键字相同的记录，经过排序后仍保持排序前的顺序。
3. 空间代价为Theta(1)；平均时间代价为Theta(n^2)；最差时间代价为Theta(n^2)，最好时间代价为Theta(n)，即只扫描一次序列发现已经是有序的了。
4. 实现方面，每次从序列的末尾开始冒泡，最大/最小的元素上浮到尽可能靠前的位置，冒泡(n-1)次，n为序列的长度；设置NoSwap标志位，每次扫描前初始化为true，若在某次扫描过后，发现序列已经是有序的，即NoSwap保持true，退出排序算法。

代码清单：

#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;

#define MAXN 12

struct _point
{
	int x, y, z;
} p[MAXN];

struct _dist
{
	int from, to;
	double dis;
} d[MAXN*MAXN/2];

int initPointSet()
{
	int n, a, b, c;
	scanf("%d", &n);

	for (int i=0; i<n; ++i)
	{
		scanf("%d%d%d", &a, &b, &c);
		p[i].x=a;
		p[i].y=b;
		p[i].z=c;
	}

	return n;
}

double calcDist(int from, int to)
{
	int dx=(p[from].x)-(p[to].x);
	int dy=(p[from].y)-(p[to].y);
	int dz=(p[from].z)-(p[to].z);

	return sqrt( double(dx*dx + dy*dy + dz*dz) );
}

int calcDistSet(int n)
{
	int k=0;
	for (int i=0; i<n; ++i)		//按照点的标号建立距离集合，即(0,1)...(0,9)(1,0)(1,2)...(1,9)...
	{
		for (int j=0; j<n; ++j)
		{
			if (i<j)
			{
				d[k].from=i;
				d[k].to=j;
				d[k].dis=calcDist(i, j);
				++k;
			}
		}
	}

	return k;
}

//冒泡排序是稳定的，因为每次都是相邻的元素比较。
//距离集合在建立的时候已经是按照点出现的先后顺序。
//因此，直接对距离进行一次冒泡排序即可。
void bubbleSortbyDist(int k)
{
	bool NoSwap;
	int last=MAXN*MAXN/2-1;	//用d[]数组最后一个元素作为交换所用的额外O(1)的空间。
	for (int i=0; i<k-1; ++i)	//要进行k-1次冒泡。
	{
		NoSwap=true;

		for (int j=k-1; j>i; --j)	//从队尾向队首冒泡
		{
			if ( d[j].dis>d[j-1].dis )
			{
				d[last].from=d[j].from;
				d[last].to=d[j].to;
				d[last].dis=d[j].dis;

				d[j].from=d[j-1].from;
				d[j].to=d[j-1].to;
				d[j].dis=d[j-1].dis;

				d[j-1].from=d[last].from;
				d[j-1].to=d[last].to;
				d[j-1].dis=d[last].dis;

				NoSwap=false;
			}
						
		}

		if (NoSwap==true)
		{
			return;
		}
	}
}

void printSortedDistSet(int k)
{
	for (int i=0; i<k; ++i)
	{
		int from=d[i].from;
		int to=d[i].to;
		printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n", p[from].x, p[from].y, p[from].z, p[to].x, p[to].y, p[to].z, d[i].dis);
	}
}

int main()
{
	freopen("D:\\in.txt", "r", stdin);
	freopen("D:\\out.txt", "w", stdout);

	int n, k;

	n=initPointSet();
	k=calcDistSet(n);
	bubbleSortbyDist(k);
	printSortedDistSet(k);

	return 0;
}