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-;
 const double pi = acos(-1.0);
 const double inf = ~0u>>;
 struct point
 {
     double x,y;
     double a;
     int flag;
     point(double x=,double y = ):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 ;
     return x<?-:;
 }
 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 = ; 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 =,b = ;
         for(i = ; 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<)
         {
             printf("%d\n",n);
             continue;
         }
         int ans = max(a,b);
         for(i = ; i < n; i++)
         {
             swap(q[i],q[]);
             for(j =  ; j < n; j++)
                 p[j] = q[j];
             Cal_Angle(p[],p,n);
             sort(p+,p+n,cmp_angle);
             for(j = n-; j >  ; j--)
                 p[j].a-=p[].a;
             double ani = p[].a,anj = pi+ani;
             int on_red = ,on_blue = ,under_red = , under_blue = ,red = ,blue = ;
             int g = ;
             while(dcmp(p[g].a-ani)==&&g<n)
             {
                 p[g++].flag?on_red++:on_blue++;
             }
             int tk = n;
             for(j = g; j < n; j++)
             {
                 if(dcmp(p[j].a-anj)>)
                 {
                     tk = j;
                     break;
                 }
                 if(dcmp(p[j].a-anj)==)
                 {
                     while(dcmp(p[j].a-anj)==&&j<n)
                     {
                         p[j++].flag?under_red++:under_blue++;
                     }
                     tk = j;
                     break;
                 }
                 p[j].flag?red++:blue++;
             }
             int ta = ,tb = ;
             p[].flag?ta++:tb++;
 
             int k1 = red+on_red+under_red++b-blue-tb;
             int k2 = blue+on_blue+under_blue++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 = ;
 
                 if(tk==n||p[tk].a-anj>p[g].a-ani)
                 {
                     ani = p[g].a;
                     anj = ani+pi;
                     while(dcmp(p[g].a-ani)==&&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)==&&tk<n)
                     {
                         p[tk++].flag?under_red++:under_blue++;
                     }
                     while(dcmp(p[g].a-ani)==&&g<n)
                     {
                         p[g].flag?on_red++:on_blue++;
                         p[g++].flag?red--:blue--;
                     }
                 }
 
                 int k1 = red+on_red+under_red++b-blue-tb;
                 int k2 = blue+on_blue+under_blue++a-red-ta;
                 ans = max(ans,max(k1,k2));
             }
         }
         printf("%d\n",ans);
     }
     return ;
 }