POJ 2008

这道题，说实话，细节很多。不过，我没想到，光细节就能搞死人了。。。

参考了http://www.cppblog.com/varg-vikernes/archive/2010/03/12/109559.html

首先，要把所有牛放到坐标系上来表示。目的，就是求出包含最多点的直角三角形。
直角三角形的两条直角边上都必须有点，也就是一组牛中的具有最小height的点和具有最小width的点。
直角三角形的边长也是固定的，cw = C/B，ch = C/A。这个还好说，从那个限制条件可以推出来的。初中都学过，呵呵。

Step1：求出经过一个点的所有可能存在的三角形。
其实也就是在该点下方的灰色区域中选择点来确定一个三角形。

Step2：求出经过一个点的所有可能存在的三角形中，最多包含的点数。
解法相当精妙。

求一个三角形内的点数，可以分解为一个矩形内的点数减去一个梯形内的点数。

用这个方法，求出最上面那个三角形的点数之后。可以继续递推得到下面其他三角形的点数。

也就是加上一个矩形，再减去一个梯形。
如果点按照高度排序以后，那么后面矩形里的点一定是后出现的。这样就可以做到随时增加矩形。
但是减去梯形这个操作，就难理解一点，把点按照A*H + B*W来排序，就能保证后面梯形里的点一定是后出现的。

可见，A*H + B*W 值的大小决定了他们的位置分布。完全可以保证这个顺序。
这种数形结合的方法实在是相当精妙！

在退出点的时候，我选择用优先队列来做。写得很锉

 #include <cstdio>
 #include <iostream>
 #include <cstring>
 #include <cctype>
 #include <vector>
 #include <queue>
 #include <algorithm>
 #define LL unsigned __int64
 #pragma comment(linker, "/STACK:1024000000,1024000000")
 using namespace std; 

 const int N=;

 struct Node{
     int x,y;
     int AH;
     bool operator <(const Node &a) const {
         if(y>a.y) return true;
         else if(y==a.y){
             if(x<a.x) return true;
         }
         return false;
     }
 }node[N];
 int n,A,B,C,xh,yh;
 struct Int_Node{
     int AH;
     Int_Node(int x){AH=x;};
     bool operator<(const Int_Node &a)const {
         if(AH<a.AH) return true;
         return false;
     }
 };
 priority_queue<Int_Node>Q;

 int main(){
     int ah,ans=;
     while(scanf("%d",&n)!=EOF){
             ans=;
             scanf("%d%d%d",&A,&B,&C);
             yh=C/B; xh=C/A;
             for(int i=;i<n;i++){
                 scanf("%d%d",&node[i].x,&node[i].y);
                 node[i].AH=A*node[i].x+B*node[i].y;
             }
             sort(node,node+n);
             for(int i=;i<n;i++){
                 int xmin=node[i].x,ymin=node[i].y;
                 ah=A*xmin+B*ymin;
                 int j;
                 for(j=;j<i;j++){
                     if(node[j].y==ymin) break;
                     if(node[j].x<=xmin+xh&&node[j].y<=ymin+yh&&node[j].x>=xmin)
                         if(A*node[j].x+B*node[j].y-ah<=C)
                         Q.push(Int_Node(node[j].AH));
                 }
                 for(j;j<n&&node[j].x<=xmin+xh&&node[j].y==ymin&&node[j].x>=xmin;j++)
                 Q.push(Int_Node(node[j].AH));
                 int ts=Q.size();
                 ans=max(ans,ts);
                 for(int k=j;node[k].y+yh>=node[i].y&&k<n;k++){
                     if(node[k].y<ymin){
                         ymin=node[k].y;
                         ah=A*xmin+B*ymin;
                         int p;
                         for(p=k;node[p].y==ymin&&p<n;p++){
                             if(node[p].x<=xmin+xh&&node[p].x>=xmin){
                                 Q.push(Int_Node(node[p].AH));
                             }
                         }
                         k=p-;int tmp;
                         while(!Q.empty()){
                             tmp=Q.top().AH;
                             if(tmp-ah>C){
                                 Q.pop();
                             }
                             else
                                 break;
                         }
                         ts=Q.size();
                         ans=max(ans,ts);
                     }
                 }
                 while(!Q.empty())
                 Q.pop();
             }
             printf("%d\n",ans);
     }
     return ;
 }