bzoj 1071: [SCOI2007]组队

Description

　　NBA每年都有球员选秀环节。通常用速度和身高两项数据来衡量一个篮球运动员的基本素质。假如一支球队里
速度最慢的球员速度为minV，身高最矮的球员高度为minH，那么这支球队的所有队员都应该满足: A * ( height
– minH ) + B * ( speed – minV ) <= C 其中A和B，C为给定的经验值。这个式子很容易理解，如果一个球队的
球员速度和身高差距太大，会造成配合的不协调。 请问作为球队管理层的你，在N名选秀球员中，最多能有多少名
符合条件的候选球员。

Input

　　第一行四个数N、A、B、C 下接N行每行两个数描述一个球员的height和speed

Output

　　最多候选球员数目。

Sample Input

4 1 2 10
5 1
3 2
2 3
2 1

Sample Output

4

HINT

数据范围： N <= 5000 ,height和speed不大于10000。A、B、C在长整型以内。

2016.3.26 数据加强 Nano_ape 程序未重测

Source

一道火得冒烟的单调性的题目；

首先我们通过移项整理式子得到这样一个东西 A*height+B*speed<=C+A*minh+B*minv;

我们发现就算按正常套路我们固定一个minh再算一个还是没有单调性，那么我们只好minh和minv都枚举了；

我们假设外层枚举minv，内层枚举minh，那么A*height+B*speed在第二层枚举的时候是单调递增的，

那么我们用一个数组来按照A*height+B*speed来sort之后，那么合法的指针就是单调递增的了；

可是现在还有一个很严肃的问题，就是在这连续的合法区间中我们还要保证height>=minh,speed>=minv；

这貌似要套个树状数组之类的数据结构，肯定会TLE;

于是我们搞一个很骚的操作，我们先把满足一定条件的speed的加入，在删掉不合法的height;

加入speed合法的话，则minv<=speed<=minv+C/B,后面那个是因为如果speed>minv+C/B,那么A*height<A*minh,显然不行；

现在我们还需要删去height<minh的东西，我们发现如果我们按照上面的要求加入合法的speed的话，那么一定保证了A*height>A*minh''(minh''表示之前枚举过的某个minh)

所以删掉的数一定在之前枚举minh''的时候加入过，只是这个时候因为minh变大了而变得不合法，所以不会删掉原本就没有加过的东西；

所以我们得到了一个O(n^2)的解决方案；

//MADE BY QT666
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;
const int N=100050;
struct data{
    ll h,v,tot;
}g[N],g2[N],g3[N];
bool cmp1(const data &a,const data &b){return a.tot<b.tot;}
bool cmp2(const data &a,const data &b){return a.h<b.h;}
bool cmp3(const data &a,const data &b){return a.v<b.v;}
int main(){
    int n;ll A,B,C;
    cin>>n>>A>>B>>C;
    for(int i=1;i<=n;i++){
	scanf("%lld%lld",&g[i].h,&g[i].v);g[i].tot=A*g[i].h+B*g[i].v;
	g2[i].h=g[i].h,g2[i].v=g[i].v,g2[i].tot=g[i].tot;
	g3[i].h=g[i].h,g3[i].v=g[i].v,g3[i].tot=g[i].tot;
    }
    sort(g+1,g+1+n,cmp1);
    sort(g2+1,g2+1+n,cmp2);
    sort(g3+1,g3+1+n,cmp3);
    int ans=0;
    for(int i=1;i<=n;i++){
	int l1=0,l2=0;
	ll minv=g3[i].v;
	ll limv=minv+C/B;
	int cnt=0;
	for(int j=1;j<=n;j++){
	    ll limtot=C+A*g2[j].h+B*minv;
	    while(l1+1<=n&&g[l1+1].tot<=limtot){
		l1++;
		if(minv<=g[l1].v&&g[l1].v<=limv) cnt++; 
	    }
	    while(l2+1<=n&&g2[l2+1].h<g2[j].h){
		l2++;
		if(minv<=g2[l2].v&&g2[l2].v<=limv) cnt--;
	    }
	    ans=max(ans,cnt);
	}
    }
    cout<<ans<<endl;
    return 0;
}