POJ1696-Space Ant

Space Ant

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 3054		Accepted: 1950

Description

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
//AC代码+解释

/*
题意：
空间蚂蚁

描述最令人兴奋的空间发现发生在20世纪末的时候。1999年,科学家追踪下来蚂蚁生物Y1999称之为M11行星。
只有一只眼睛在左边的头,仅仅三脚都在右边的身体和有三个走限制:
1。它并不会向右转由于其特殊的身体结构。
2.它离红路径漫步间。
3.它憎恨过去一个以前红颜色的路径,并且不会那样想。
图片通过发现指出,宇宙飞船Y1999植物的生长在行星上的特殊要点。
分析几千照片导致发现一个魔术的协调发展管理点的植物。
这个座标系统在x轴和y轴两种植物,有相同的x或y。
一个M11要吃一个确切的植物里每一天来维持生命。
当它吃一植物,它存在在今天余下的时间里没有移动。
第二天,它寻找另一株植物到那里去,又要吃它。
如果它不能达成任何其它植物死的,由一天结束。
注意到能达到一种植物在任何的距离。
问题是要找到的路径M11让它住久。
输入是一组(x,y协调的植物。
假设一个与坐标(xA,yA)的植物以最小的纵坐标。
M11始于点(0,yA)朝着植物
答:注意到解决路径不应该交叉本身,所有的转应该逆时针旋转。
同时也注意到解决之道可能访问超过两个工厂位于同一直线。
输入第一行输入是M,大量的测试用例被解决(1 < =n< = 10)。
对于每个测试情形,第一行是N,大量的植物在测试用例(1 < = N < = 50),
其次为N线路的每个植物数据。
每个植物数据由三个整数分别表示:第一个数字是独特的植物指数(1 . . N),
然后是两个正整数代表x和y坐标的植物
植物的排序命令在指数中增加在输入文件
假设值最多坐标100。输出输出应该有一个独立的生产线,每个测试用例的解决方案
解决方法是植物的数量解决路径,其次是指数参观工厂的顺序路径的访问

解题思路：极角排序
对于题目所输入的点,先找出最左下方的顶点(即纵坐标最小的顶点)
然后对剩下的顶点按照对与左下点的极角排序,然后反复找最左下的点,反复进行极角排序
同时记录排序后左下的顶点
极角排序方法:利用叉积,看向量p1和p2的叉积是否小于零,是则说明p1在p2逆时针方向
(即p1的极角比p2的大),极角相同则按离p0距离降序排序
*/
#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#include<cmath>
#include<algorithm>
#include<cmath>
#define eps 1e-8
const int Max=51;
using namespace std;
typedef struct Node
{
    double x;
    double y;
    int num;
}point;
point u[Max],v[Max];
int pos;
double Distance(point p1,point p2)// 返回两点之间欧氏距离
{
	return( sqrt( (p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y) ) );
}
double xmult(point p0,point p1,point p2)
{
	return(p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);
}
bool cmp(const point &a,const point &b)//极角排序，极角相同按离p0距离降序排
{
    double c = xmult(u[pos],a,b);
    if(c>0)
    return true;
    else if(c==0&&Distance(u[pos],a)<Distance(u[pos],b))
    return true;
    return false;
}
int main()
{
    int T;
    int n,m,i,j;
    cin>>T;
    while(T--)
    {
        cin>>n;
        cin>>u[0].num>>u[0].x>>u[0].y;
        for(i=1;i<n;i++)
        {
            cin>>u[i].num>>u[i].x>>u[i].y;
            if(u[i].y<u[0].y)
            swap(u[0],u[i]);
        }
        j=0;
        pos=0;
        sort(u+1,u+n,cmp);
        v[j++]=u[pos++];
        for(i=2;i<n;i++)          //反复进行极角排序
        {
            sort(u+pos,u+n,cmp);
            v[j++]=u[pos++];
        }
        v[j++]=u[pos++];
        cout<<n;
        for(i=0;i<n;i++)
        cout<<" "<<v[i].num;
        cout<<endl;
    }
    return 0;
}