bzoj1071

朴素的做法显然是O(n3)的
考虑优化，我们将约束条件变形为A*h+B*v<=A*minh+B*minv+c
右边是一个定值，当右边确定了minh之后，随着minv的增大，原来满足条件的且v>=minv的一定还满足条件
然后我们只要先对A*h+B*v排序，然后穷举minh，然后扫一遍即可
O(n2)的算法很显然，我正好卡着时限过去的……
但这道题的本意肯定是有O(nlogn)的算法，求教导

type node=record
       h,v,s:longint;
     end;

var f,v:array[0..10010] of longint;
    h:array[0..10010] of boolean;
    w:array[0..5010] of node;
    ans,t,m,x,y,n,i,j,sum,s,a,b,c,k:longint;

procedure swap(var a,b:node);
  var c:node;
  begin
    c:=a;
    a:=b;
    b:=c;
  end;

procedure sort(l,r: longint);
  var i,j,x: longint;
  begin
    i:=l;
    j:=r;
    x:=w[(l+r) div 2].s;
    repeat
      while w[i].s<x do inc(i);
      while x<w[j].s do dec(j);
      if not(i>j) then
      begin
        swap(w[i],w[j]);
        inc(i);
        j:=j-1;
      end;
    until i>j;
    if l<j then sort(l,j);
    if i<r then sort(i,r);
  end;

begin
  readln(n,a,b,c);
  for i:=1 to n do
  begin
    readln(x,y);
    h[x]:=true;
    if x>m then m:=x;
    v[y]:=1;
    w[i].h:=x;
    w[i].v:=y;
    w[i].s:=a*x+b*y;
  end;
  sort(1,n);
  for i:=1 to 10000 do
    if v[i]=1 then
    begin
      inc(t);
      f[t]:=i;  //表示v可能的数字
    end;

  for i:=1 to m do
  begin
    if not h[i] then continue;  //穷举minh
    fillchar(v,sizeof(v),0);
    sum:=0;
    k:=1;
    for j:=1 to t do
    begin
      if j<>1 then
        sum:=sum-v[f[j-1]]; //对于当前minv，小于的不算
      s:=a*i+b*f[j]+c;
      while (k<=n) and (w[k].s<=s) do
      begin
        if (w[k].h>=i) and (w[k].v>=f[j]) then
        begin
          inc(sum);
          inc(v[w[k].v]);  //方便随着minv的增大，快速减去小于minv的数目
        end;
        inc(k);
      end;
      if sum>ans then ans:=sum;
      if k>n then break; //后面一定只减不增
    end;
  end;
  writeln(ans);
end.