uva 1606 amphiphilic carbon molecules【把缩写写出来，有惊喜】（滑动窗口）——yhx

Shanghai Hypercomputers, the world's largest computer chip manufacturer, has invented a new class
of nanoparticles called Amphiphilic Carbon Molecules (ACMs). ACMs are semiconductors. It means
that they can be either conductors or insulators of electrons, and thus possess a property that is very
important for the computer chip industry. They are also amphiphilic molecules, which means parts
of them are hydrophilic while other parts of them are hydrophobic. Hydrophilic ACMs are soluble
in polar solvents (for example, water) but are insoluble in nonpolar solvents (for example, acetone).
Hydrophobic ACMs, on the contrary, are soluble in acetone but insoluble in water. Semiconductor
ACMs dissolved in either water or acetone can be used in the computer chip manufacturing process.
Fig.1
As a materials engineer at Shanghai
Hypercomputers, your job is to prepare
ACM solutions from ACM particles. You
go to your factory everyday at 8 am and
nd a batch of ACM particles on your
workbench. You prepare the ACM so-
lutions by dripping some water, as well
as some acetone, into those particles and
watch the ACMs dissolve in the solvents.
You always want to prepare unmixed solu-
tions, so you rst separate the ACM parti-
cles by placing an Insulating Carbon Par-
tition Card (ICPC) perpendicular to your
workbench. The ICPC is long enough to
completely separate the particles. You then drip water on one side of the ICPC and acetone on the
other side. The ICPC helps you obtain hydrophilic ACMs dissolved in water on one side and hydropho-
bic ACMs dissolved in acetone on the other side. If you happen to put the ICPC on top of some ACM
particles, those ACMs will be right at the border between the water solution and the acetone solution,
and they will be dissolved. Fig.1 shows your working situation.
Your daily job is very easy and boring, so your supervisor makes it a little bit more challenging by
asking you to dissolve as much ACMs into solution as possible. You know you have to be very careful
about where to put the ICPC since hydrophilic ACMs on the acetone side, or hydrophobic ACMs on
the water side, will not dissolve. As an experienced engineer, you also know that sometimes it can be
very difficult to nd the best position for the ICPC, so you decide to write a program to help you. You
have asked your supervisor to buy a special digital camera and have it installed above your workbench,
so that your program can obtain the exact positions and species (hydrophilic or hydrophobic) of each
ACM particle in a 2D pictures taken by the camera. The ICPC you put on your workbench will appear
as a line in the 2D pictures.
Input
There will be no more than 10 test cases. Each case starts with a line containing an integer N, which
is the number of ACM particles in the test case. N lines then follow. Each line contains three integers
x, y, r, where (x; y) is the position of the ACM particle in the 2D picture and r can be 0 or 1, standing
for the hydrophilic or hydrophobic type ACM respectively. The absolute value of x, y will be no larger
than 10000. You may assume that N is no more than 1000. N = 0 signies the end of the input and
need not be processed.
Output
For each test case, output a line containing a single integer, which is the maximum number of dissolved
ACM particles.
Note: Fig.2 shows the positions of ACM particles and the best ICPC position for the last test case in
the sample input.

 #include<cstdio>
 #include<cmath>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 #define M(a) memset(a,0,sizeof(a))
 struct pnt
 {
     int x,y;
     bool b;
     double k;
 }a[],t[];
 bool cmp(const pnt &a,const pnt &b)
 {
     return a.k<b.k;
 }
 int max(int a,int b)
 {
     return a>b?a:b;
 }
 int main()
 {
     int i,j,k,m,n,p,q,x,y,z,ans,l,r,cnt;
     while (scanf("%d",&n)&&n)
     {
         M(a);
         M(t);
         for (i=;i<=n;i++)
           scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].b);
         if (n<=)
         {
             printf("%d\n",n);
             continue;
         }
         ans=-;
         for (i=;i<=n;i++)
         {
             k=;
             for (j=;j<=n;j++)
               if (i!=j)
               {
                   k++;
                   t[k].x=a[j].x-a[i].x;
                   t[k].y=a[j].y-a[i].y;
                   if (a[j].b)
                   {
                       t[k].x=-t[k].x;
                       t[k].y=-t[k].y;
                 }
                   t[k].k=atan2(t[k].y,t[k].x);
               }
             sort(t+,t+k+,cmp);
             for (l=,r=,cnt=;l<=k;l++)
             {
                 if (r==l)
                 {
                     r=r%k+;
                     cnt++;
                 }
                 while (r!=l&&t[l].y*t[r].x<=t[l].x*t[r].y)
                 {
                     r=r%k+;
                     cnt++;
                 }
                 cnt--;
                 ans=max(ans,cnt);
             }
         }
         printf("%d\n",ans);
     }
 }

题目里先后出现了ACM和ICPC，这一定只是巧合。

没有什么特殊的算法，但不好想，也有很多细节容易写错。

一定存在某种最优情况，分界线至少经过两个点。否则可以平移它使它经过两个点而不减少答案数。

对每个黑点，作关于原点（即枚举的那个点）的对称点，问题就转化为计算一边的点的个数。

枚举每个点，以该点为原点计算每个点的位置，按角度从小到大排序（不能直接用斜率k=tan，否则y轴上的点会出错。）于是用滑动窗口一边进一边出，枚举分界线的另一个点，每滑过左边的一个点就向右边滑动，由于每个点都会作为起点和终点滑过一次，算上排序，复杂度为O(nlogn)。避免O(n^2)的枚举+判断。

总复杂度为O(n^2logn)。

计数和滑动的地方容易写错，而且要考虑绕圈。