poj2280Amphiphilic Carbon Molecules(极角排序)

链接

卡了几天的破题，对于hdu的那份数据，这就一神题。。

借助极角排序，枚举以每一个点进行极角排序，然后构造两条扫描线，一个上面一个下面，两条同时走，把上线和下线的点以及上线左边的点分别统计出来，如下图

样例3：

假如现在以d为p[0],那么所有可能结果一定是他与其他点的连线所分割的平面，那么首先以de为上线，下线的角度为上线+pi，两条线始终维护着这样的关系。de的下一个点为f，di的下一个点为c ，比较一下两者需要转的角度，选取较小角度转，注意一下相同的时候的处理。

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>
#include<vector>
#include<cmath>
#include<queue>
#include<set>
using namespace std;
#define N 1010
#define LL long long
#define INF 0xfffffff
const double eps = 1e-8;
const double pi = acos(-1.0);
const double inf = ~0u>>2;
struct point
{
    double x,y;
    double a;
    int flag;
    point(double x=0,double y = 0):x(x),y(y) {}
} p[N],q[N];
int tx[N],ty[N];
typedef point pointt;
point operator -(point a,point b)
{
    return point(a.x-b.x,a.y-b.y);
}
int dcmp(double x)
{
    if(fabs(x)<eps) return 0;
    return x<0?-1:1;
}
double cross(point a,point b)
{
    return a.x*b.y-a.y*b.x;
}
double mul(point a,point b,point c)
{
    return cross(b-a,c-a);
}
double dis(point a)
{
    return sqrt(a.x*a.x+a.y*a.y);
}
int dot_online_in(point p,point l1,point l2)
{
    return !dcmp(mul(p,l1,l2))&&(l1.x-p.x)*(l2.x-p.x)<eps&&(l1.y-p.y)*(l2.y-p.y)<eps;
}
double dot(point a,point b)
{
    return a.x*b.x+a.y*b.y;
}
double Cal_Angle(point p1,point p2)
{
    if(p1.x == p2.x && p1.y == p2.y)
        return -100.0;
    point v;
    v.x = p2.x - p1.x;
    v.y = p2.y - p1.y;
    if(p1.y <= p2.y)
        return acos(v.x/sqrt(dot(v,v)));
    return 2.0*pi - acos(v.x/sqrt(dot(v,v)));
}

void Cal_Angle(point pp,point p[],int n)
{
    for(int i = 0; i < n; ++i)
    {
        p[i].a = Cal_Angle(pp,p[i]);
    }
}
bool cmp_angle(point p1,point p2)
{
    return p1.a < p2.a;
}
int main()
{
    int i,j,n;
    while(scanf("%d",&n)&&n)
    {
        int a =0,b =0 ;
        for(i = 0; i < n; i++)
        {
            scanf("%lf%lf%d",&p[i].x,&p[i].y,&p[i].flag);
            q[i] = p[i];
            if(p[i].flag) a++;
            else b++;
        }
        if(n<3)
        {
            printf("%d\n",n);
            continue;
        }
        int ans = max(a,b);
        for(i = 0; i < n; i++)
        {
            swap(q[i],q[0]);
            for(j = 0 ; j < n; j++)
                p[j] = q[j];
            Cal_Angle(p[0],p,n);
            sort(p+1,p+n,cmp_angle);
            for(j = n-1; j > 0 ; j--)
                p[j].a-=p[1].a;
            double ani = p[1].a,anj = pi+ani;
            int on_red = 0,on_blue = 0,under_red = 0, under_blue = 0,red = 0,blue = 0;
            int g = 1;
            while(dcmp(p[g].a-ani)==0&&g<n)
            {
                p[g++].flag?on_red++:on_blue++;
            }
            int tk = n;
            for(j = g; j < n; j++)
            {
                if(dcmp(p[j].a-anj)>0)
                {
                    tk = j;
                    break;
                }
                if(dcmp(p[j].a-anj)==0)
                {
                    while(dcmp(p[j].a-anj)==0&&j<n)
                    {
                        p[j++].flag?under_red++:under_blue++;
                    }
                    tk = j;
                    break;
                }
                p[j].flag?red++:blue++;
            }
            int ta = 0,tb = 0;
            p[0].flag?ta++:tb++;

            int k1 = red+on_red+under_red+1+b-blue-tb;
            int k2 = blue+on_blue+under_blue+1+a-red-ta;

            ans = max(ans,max(k1,k2));
            if(g==n) continue;

            while(tk<n)
            {
                red+=under_red,blue+=under_blue;
                on_red = on_blue = under_blue = under_red = 0;

                if(tk==n||p[tk].a-anj>p[g].a-ani)
                {
                    ani = p[g].a;
                    anj = ani+pi;
                    while(dcmp(p[g].a-ani)==0&&g<n)
                    {
                        p[g].flag?on_red++:on_blue++;
                        p[g++].flag?red--:blue--;
                    }
                }
                else
                {
                    anj = p[tk].a;
                    ani = anj-pi;
                    while(dcmp(p[tk].a-anj)==0&&tk<n)
                    {
                        p[tk++].flag?under_red++:under_blue++;
                    }
                    while(dcmp(p[g].a-ani)==0&&g<n)
                    {
                        p[g].flag?on_red++:on_blue++;
                        p[g++].flag?red--:blue--;
                    }
                }

                int k1 = red+on_red+under_red+1+b-blue-tb;
                int k2 = blue+on_blue+under_blue+1+a-red-ta;
                ans = max(ans,max(k1,k2));
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}