枚举A0,B0,找清真，直到找到第一个不清真的，这时记录清真个数，找下一个B0直到B0是最后一个换A0或者最后一个桃子也请真换A0。（讲的不太清楚，看代码，不太好理解）
```cpp
#include<iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>
#include <climits>
#include <algorithm>
#include <map>
#include <queue>
#include <vector>
#include <string>
#include <cstring>
using namespace std;
int n,c1,c2,c3,ans=0,sum,maxSweet=0;
int a[2005]= {0},b[2005]= {0},halal[2005]= {0};
struct marked {
int id,value;
} sortedB[2005],sortedKey[2005];;
bool comp(marked a,marked b) {
return a.value<b.value;
}
int main() {

scanf("%d%d%d%d",&n,&c1,&c2,&c3);
for(int i=0; i<n; i++) {
scanf("%d%d",a+i,b+i);
sortedB[i].id=sortedKey[i].id=i;
sortedB[i].value=b[i];
sortedKey[i].value=a[i]*c1+b[i]*c2-c3;
maxSweet=max(b[i],maxSweet);
}
sort(sortedB,sortedB+n,comp);
sort(sortedKey,sortedKey+n,comp);
for(int i=0; i<n; i++) {
int k=0,sum=0,j=0;
memset(halal,0,sizeof(halal));
for(; j<n; j++) {
while(k<n&&sortedKey[k].value<=c1*a[i]+c2*sortedB[j].value) {
if(a[sortedKey[k].id]>=a[i]&&b[sortedKey[k].id]>=sortedB[j].value) {
sum++;//多少个清真
halal[b[sortedKey[k].id]]++;//halal[i]：甜度为i的有几个清真
}
k++;
}
if(j) {//去重，这时前一个B0已经不清真了
sum-=halal[sortedB[j-1].value];
halal[sortedB[j-1].value]=0;
}
ans=max(ans,sum);
}
}
printf("%d",ans);
return 0;
}
```

我总算做题过100了

测试数据 #0: Accepted, time = 15 ms, mem = 16576 KiB, score = 10
测试数据 #1: Accepted, time = 15 ms, mem = 16580 KiB, score = 10
测试数据 #2: Accepted, time = 15 ms, mem = 16576 KiB, score = 10
测试数据 #3: Accepted, time = 15 ms, mem = 16572 KiB, score = 10
测试数据 #4: Accepted, time = 62 ms, mem = 16576 KiB, score = 10
测试数据 #5: Accepted, time = 46 ms, mem = 16576 KiB, score = 10
测试数据 #6: Accepted, time = 31 ms, mem = 16576 KiB, score = 10
测试数据 #7: Accepted, time = 93 ms, mem = 16572 KiB, score = 10
测试数据 #8: Accepted, time = 140 ms, mem = 16572 KiB, score = 10
测试数据 #9: Accepted, time = 140 ms, mem = 16576 KiB, score = 10
Accepted, time = 572 ms, mem = 16580 KiB, score = 100
平方级的秒不掉啊？你们是log级的？

o-yeah

Accept!!!

一直卡在如何计算去掉重复的....思想太死板了我

对于b[j]=b[j-1] f[j]可以不等于f[j-1]啊

Orz楼下第250个AC……

ms楼下的方程意义不是你说的那个样子吧。。。。

f表示以Ai,Bj为最小值，去掉到目前为止，重复的b[j]也就是，b[j]=b[j-1]时的最大值

真猥琐呀……

开三个数据a,b,s分别存ai,bi,ai*c1+bi*c2.

将b,s数组排序，同时这两个数组各加上一个下标数组记录排序后该数据原来的位置。

要满足ai*c1+bi*c2=a0)是否成立，如果满足就加1，这个过程我们就用到了DP，其实是递推，因为没有最优决策。

f表示a0=a[i],b0=b[j]时的最大值。

那么f=f+加上我们扫描s符合的个数。

对于某个a0，我们枚举b0的过程中，s的指针都是向右不会回溯。

当枚举下一个b0的时候，可能会导致前面一个b0失效，因为b0=b[i]>b所以b就不能再是最小值了,所以如果b用过的话，f要减一。

var

i,j,n,c1,c2,c3,t,a0,b0,h,ans:longint;

a,b,oa,ob,s,p,q:array [0..2000] of longint;

f:array [0..2000,0..2000] of longint;

v:array [0..2000] of boolean;

procedure qsort_b(l,r:longint);

var i,j,x,t:longint;

begin

i:=l; j:=r; x:=b[(l+r) div 2];

repeat

while b[i]

Accepted 有效得分：100 有效耗时：294ms

我恨sunny.......

郁闷，弱弱的思路，顺便想用比较简洁的方法把三个一起快排，结果搞成了栈溢出....分成三段之后，可以了，但是代码一下长了好多.....

思路比较简单，blog上共享~~

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 103ms

├ 测试数据 10：答案正确... 41ms

郁闷的要死，>打成

1个晚上，终于AC......排序都弄得我够呛

AC了

但求DP解法

纪念一下，第一道难度5的题目！！！！！！

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

总算秒杀了

Accepted 有效得分：100 有效耗时：0ms

puppy帮忙，秒杀之。。。

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 119ms

├ 测试数据 09：答案正确... 197ms

├ 测试数据 10：答案正确... 228ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：544ms

枚举有点慢，不过我的宿舍号是204，做第204个AC的也不错(^_^)

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 25ms

├ 测试数据 10：答案正确... 9ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：34ms

第202个~~

真不吉利

http://ace.delos.com/MAR04.green.htm

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

过瘾………………

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

我高兴，我徒弟过了这题。