poj1696 Space Ant

地址：

题目：

Space Ant

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 4295		Accepted: 2697

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
思路：直接用卷包裹法求凸包即可
代码：

/* 二维几何  */
/* 需要包含的头文件 */
#include <cstdio>
#include <cmath >
#include <iostream>
#include <algorithm>
#include <cstring>
#include <map>
using namespace std;
/** 常用的常量定义 **/
const double INF  = 1e200;
const double eps  = 1e-10;
const double PI  = acos(-1.0);
const int Max = 100;
/** 基本几何结构 **/
struct Point
{
    double x,y;
    Point(double a=0, double b=0){x=a,y=b;}
    bool operator<(const Point &ta)const
    {
        if(x==ta.x)     return y<ta.y;
        return x<ta.x;
    }
    friend Point operator+(const Point &ta,const Point &tb)
    {
        return Point(ta.x+tb.x,ta.y+tb.y);
    }
    friend Point operator-(const Point &ta,const Point &tb)
    {
        return Point(ta.x-tb.x,ta.y-tb.y);
    }
};
struct Vec2D        //二维向量，*重载为点乘，/重载为叉乘
{
    double x,y;
    Vec2D(double ta,double tb){x=ta,y=tb;}
    Vec2D(Point &ta){x=ta.x,y=ta.y;}
    friend double operator*(const Vec2D &ta,const Vec2D &tb)
    {
        return ta.x*tb.x+ta.y*tb.y;
    }
    friend double operator/(const Vec2D &ta,const Vec2D &tb)
    {
        return ta.x*tb.y-ta.y*tb.x;
    }
    friend Vec2D operator+(const Vec2D &ta,const Vec2D &tb)
    {
        return Vec2D(ta.x+tb.x,ta.y+tb.y);
    }
    friend Vec2D operator-(const Vec2D &ta,const Vec2D &tb)
    {
        return Vec2D(ta.x-tb.x,ta.y-tb.y);
    }
    Vec2D operator=(const Vec2D &ta)
    {
        x=ta.x,y=ta.y;
        return *this;
    }
};
struct LineSeg      //线段，重载了/作为叉乘运算符，*作为点乘运算符
{
    Point s,e;
    LineSeg(){s=Point(0,0),e=Point(0,0);}
    LineSeg(Point a, Point b){s=a,e=b;}
    double lenth(void)
    {
        return sqrt((s.x-e.x)*(s.x-e.x)+(s.y-e.y)*(s.y-e.y));
    }
    friend double operator*(const LineSeg &ta,const LineSeg &tb)
    {
        return (ta.e.x-ta.s.x)*(tb.e.x-tb.s.x)+(ta.e.y-ta.s.y)*(tb.e.y-tb.s.y);
    }
    friend double operator/(const LineSeg &ta,const LineSeg &tb)
    {
        return (ta.e.x-ta.s.x)*(tb.e.y-tb.s.y)-(ta.e.y-ta.s.y)*(tb.e.x-tb.s.x);
    }
    LineSeg operator=(const LineSeg &ta)
    {
        s=ta.s,e=ta.e;
        return *this;
    }
};
struct Line         // 直线的解析方程 a*x+b*y+c=0  为统一表示，约定 a >= 0
{
    double a,b,c;
    Line(double d1=1, double d2=-1, double d3=0){ a=d1,b=d2,c=d3;}
};

double getdis(Point &ta,Point &tb)
{
    return sqrt((ta.x-ta.x)*(ta.x-tb.x)+(ta.y-tb.y)*(ta.y-tb.y));
}
/** ************凸包graham算法****************
        寻找凸包的graham 扫描法
        PS(PointSet)为输入的点集；
        tb为输出的凸包上的点集，按照逆时针方向排列;
        n为PointSet中的点的数目
        num为输出的凸包上的点的个数
****************************************** **/
bool cmp(const Point &ta,const Point &tb)// 选取与最后一条确定边夹角最小的点，即余弦值最大者
{
//    double tmp=LineSeg(ps[0],ta)/LineSeg(ps[0],tb);
//    if(fabs(tmp)<eps)
//        return getdis(ps[0],ta)<getdis(ps[0],tb);
//    else if(tmp>0)
//        return 1;
    return 0;
}
void graham(Point ps[],Point tb[],int n,int &num)
{
    int cur=0,top=2;
    for(int i=1;i<n;i++)
        if(ps[cur].y>ps[i].y || (ps[cur].y==ps[i].y &&ps[cur].x>ps[i].x))
            cur=i;
    swap(ps[cur],ps[0]);
    sort(ps+1,ps+n,cmp);
    tb[0]=ps[0],tb[1]=ps[1],tb[2]=ps[2];
    for(int i=3;i<n;i++)
    {
        while(LineSeg(tb[top-1],tb[top])/LineSeg(tb[top-1],ps[i])<0)
            top--;
        tb[++top]=ps[i];
    }
    num=top+1;
}
/** 卷包裹法求点集凸壳，参数说明同graham算法 **/
void ConvexClosure(Point ps[],Point tb[],int n,int &num)
{
    LineSeg lx,ly;
    int cur;
    bool vis[Max];
    num=-1,cur=0;
    memset(vis,0,sizeof(vis));
    for(int i=1;i<n;i++)
        if(ps[cur].y>ps[i].y || (ps[cur].y==ps[i].y &&ps[cur].x>ps[i].x))
            cur=i;
    tb[++num]=ps[cur];
    lx.s=Point(ps[cur].x-1,ps[cur].y),lx.e=ps[cur];
    vis[cur]=1;
    // 选取与最后一条确定边夹角最小的点，即余弦值最大者
    while(num!=n)
    {
        int ch;
        double mxcross=-2,midis,tmxcross;
        ly.s=lx.e;
        for(int i=0;i<n;i++)if(!vis[i])
        {
            ly.e=ps[i];
            tmxcross=(lx*ly)/lx.lenth()/ly.lenth();
            if(tmxcross>mxcross ||(fabs(tmxcross-mxcross)<eps && getdis(ly.s,ly.e)<midis))
                mxcross=tmxcross,midis=getdis(ly.s,ly.e),ch=i;
        }
        tb[++num]=ps[ch],vis[ch]=1;
        lx.s=tb[num-1],lx.e=tb[num],ly.s=tb[num];
    }
}

map<Point,int>mp;
Point ps[Max],tb[Max];
int main(void)
{
    int t;cin>>t;
    while(t--)
    {
        mp.clear();
        int n,ans;cin>>n;
        for(int i=0,id,x,y;i<n;i++)
            scanf("%d%d%d",&id,&x,&y),ps[i]=Point(x,y),mp[ps[i]]=id;
        ConvexClosure(ps,tb,n,ans);
        printf("%d ",ans);
        for(int i=0;i<ans;i++)
            printf("%d%c",mp[tb[i]],i==ans-1?'
':' ');
    }
    return 0;
}