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;
}