计算几何——Space Ant(凸包)

题目链接:http://poj.org/problem?id=1696

The most exciting space discovery occurred at the end of the 20th century. In 1999, scientists traced down an ant-like creature in the planet Y1999 and called it M11. It has only one eye on the left side of its head and just three feet all on the right side of its body and suffers from three walking limitations:

1. It can not turn right due to its special body structure.
2. It leaves a red path while walking.
3. It hates to pass over a previously red colored path, and never does that.

The pictures transmitted by the Discovery space ship depicts that plants in the Y1999 grow in special points on the planet. Analysis of several thousands of the pictures have resulted in discovering a magic coordinate system governing the grow points of the plants. In this coordinate system with x and y axes, no two plants share the same x or y.
An M11 needs to eat exactly one plant in each day to stay alive. When it eats one plant, it remains there for the rest of the day with no move. Next day, it looks for another plant to go there and eat it. If it can not reach any other plant it dies by the end of the day. Notice that it can reach a plant in any distance.
The problem is to find a path for an M11 to let it live longest.
Input is a set of (x, y) coordinates of plants. Suppose A with the coordinates (xA, yA) is the plant with the least y-coordinate. M11 starts from point (0,yA) heading towards plant A. Notice that the solution path should not cross itself and all of the turns should be counter-clockwise. Also note that the solution may visit more than two plants located on a same straight line.

Input

The first line of the input is M, the number of test cases to be solved (1 <= M <= 10). For each test case, the first line is N, the number of plants in that test case (1 <= N <= 50), followed by N lines for each plant data. Each plant data consists of three integers: the first number is the unique plant index (1..N), followed by two positive integers x and y representing the coordinates of the plant. Plants are sorted by the increasing order on their indices in the input file. Suppose that the values of coordinates are at most 100.

Output

Output should have one separate line for the solution of each test case. A solution is the number of plants on the solution path, followed by the indices of visiting plants in the path in the order of their visits.

Sample Input

2
10
1 4 5
2 9 8
3 5 9
4 1 7
5 3 2
6 6 3
7 10 10
8 8 1
9 2 4
10 7 6
14
1 6 11
2 11 9
3 8 7
4 12 8
5 9 20
6 3 2
7 1 6
8 2 13
9 15 1
10 14 17
11 13 19
12 5 18
13 7 3
14 10 16

Sample Output

10 8 7 3 4 9 5 6 2 1 10
14 9 10 11 5 12 8 7 6 13 4 14 1 3 2

题意翻译:

‎最激动人心的太空发现发生在20世纪末。1999年,科学家在Y1999行星上追踪到一种蚂蚁状生物,并称之为M11。它只有一只眼睛在它的头的左侧,只有三英尺都在身体的右侧,并遭受三个行走限制:‎

1. ‎由于其特殊的车身结构,不能右转。‎
2. ‎它走路时留下一条红色的小路。‎
3. ‎它讨厌通过以前的红色路径,并且永远不会这样做。‎

‎发现号太空船传送的图片描绘了Y1999中的植物生长在行星上的特点。对数千张图片的分析,发现了一个神奇的坐标系,控制植物的生长点。在此具有 x 和 y 轴的坐标系中,‎‎没有两个工厂共享相同的 x 或 y‎‎。‎
‎M11每天需要只吃一株植物才能存活。当它吃一株植物时,它一整天都在那里不动。第二天,它寻找另一种植物去那里吃它。如果它无法到达任何其他植物,它会在一天结束时死亡。请注意,它可以到达任何距离的工厂。‎
‎问题是为 M11 找到一条路径,使其活得最长。‎
‎输入是植物的一组(x,y)坐标。假设坐标为坐标的 A(xA,yA)是 y 坐标最少的工厂。M11 从指向工厂 A 的点 (0,yA) 开始。 请注意,解决方案路径不应自移,并且所有转弯都应逆时针方向。另请注意,该解决方案可能会访问位于同一直线上的两个以上工厂。‎

‎输入‎

‎输入的第一行是 M,要解决的测试用例数 (1 <= M <= 10)。对于每个测试用例,第一行为 N,该测试用例中的工厂数量 (1 <= N <= 50),每个工厂数据后跟 N 行。每个工厂数据由三个整数组成:第一个数字是唯一的植物指数 (1..N),后跟两个正整数 x 和 y 表示工厂的坐标。工厂按输入文件中索引的增加顺序排序。假设坐标的值最多为 100。‎

‎输出‎

‎输出应具有用于每个测试用例的解决方案的一条单独的行。解决方案是解决方案路径上的工厂数量,然后按照参观顺序访问路径中参观工厂的数量。‎

其实这个题应该是为凸包打铺垫的题，其关键在于极角排序。

我这里也有一个疑问，为甚我的代码里面注释的一行和它下面的一行不能等价代换，它俩不是一个意思么？知道的大佬可以评论一下。

#include <iostream>
#include<cmath>
#include<cstdio>
#include<algorithm>
using namespace std;
typedef double db;
const db eps=1e-6;
const int maxn=1e3+7;
struct Point{
	int id;
	db x,y;
	Point(int id=0,db x=0,db y=0):x(x),y(y),id(id){} 
}p[maxn];
int pos;
typedef Point Vector;
int sgn(db x){
	if(fabs(x)<eps) return 0;
	if(x>0) return 1;
	return -1;
}
Vector operator+(Vector a,Vector b){
	return Vector(a.x+b.x,a.y+b.y);
}
Vector operator-(Vector a,Vector b){
	return Vector(a.x-b.x,a.y-b.y);
}
Vector operator*(Vector a,db p){
	return Vector(a.x*p,a.y*p); 
}
Vector operator/(Vector a,db p){
	return Vector(a.x/p,a.y/p); 
}
db Cross(Vector a,Vector b){
	return a.x*b.y-b.x*a.y;
} 
db Dot(Vector a,Vector b){
	return a.x*b.x+a.y*b.y;
}
db dis(Point a,Point b){
	return sqrt(Dot(a-b,a-b)); 
}
bool _cmp(Point a,Point b){
//	db temp=Cross(a-p[pos],b-p[pos]);
	db temp=(a.x-p[pos].x)*(b.y-p[pos].y)-(b.x-p[pos].x)*(a.y-p[pos].y);
	if(sgn(temp)>0) return true;
	else if(sgn(temp)==0&&sgn(dis(a,p[pos])-dis(b,p[pos]))<=0) return true;
	else return false;
}
int main(int argc, char** argv) {
	int T,n;
	cin>>T;
	while(T--){
		cin>>n;
		for(int i = 0;i<n;++i){
			cin>>p[i].id>>p[i].x>>p[i].y;
		}
		Point p0=p[0];
		int k=0;
		for(int i = 1;i<n;++i){
			if(p0.y>p[i].y||(p0.y==p[i].y&&p0.x>p[i].x)){
				p0=p[i];
				k=i;
			}
		}
		swap(p[k],p[0]);
		pos=0;
		for(int i = 1;i<n;++i){
			sort(p+i,p+n,_cmp);
			pos++;
		}
		cout<<n;
		for(int i = 0;i<n;++i){
			cout<<" "<<p[i].id;
		}
		cout<<endl;
	}
	return 0;
}