金矿师傅

时间限制：1秒  内存限制：64M

【问题描述】

　　金矿的老师傅年底要退休了。经理为了奖赏他的尽职尽责的工作，决定在一块包含 n 个采金点的长方形土地中划出一块长度为 S（X轴方向），宽度为 W（y轴方向）的区域奖励给他，老师傅可以自己选择这块地的位置，显然其中包含的采金点越多越好。

　　你的任务就是计算最多能得到多少个采金点。如果一个采金点的位置在长方形的边上，它也应当被计算在内。

【输入格式】

　　第一行有两个整数中间用一个空格隔开，表示长方形土地的长和宽即s和w。
　　第二行有一个整数n，表示金矿数量。
　　下面的n行与金矿相对应，每行两个整数x和y,中间用一个空格隔开，表示金矿的坐标。

【输出格式】

　　只有一个整数，表示选择的最大金矿的数。

【输入样例】

1 2
12
0 0
1 1
2 2
3 3
4 5
5 5
4 2
1 4
0 5
5 0
2 3
3 2

【输出样例】

4

【数据范围】

n ≤30000
1≤s,w≤10 000
-30 000<=x,y<=30 000

这道题一看没管范围直接就用bit做了，要卡常数，但是我蜜汁优化，弄出来了（极限的一个982ms过的）。

我们先离散化然后按x排序，然后一个一个区间的考虑。

我们考虑以i（离散化后）为开始的区间，然后把所以区间内的点的y加进去就好了（最好也离散一下），然后区间内的点一个一个的找以他的y为下线的区间内的点的个数。

你没看错就是这么暴力（实际上直接这样暴力你会炸，要优化）。

代码如下：（优化暗含期间）

#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=60005;

struct shu
{
    int x,y;
    friend bool operator <(shu a,shu b)
    {
        return a.x<b.x;
    }
}a[maxn];

int bit[maxn]={0},n,x1,y1,bx[maxn],by[maxn],xx=1,yy=1,b[maxn],vis[maxn],w[maxn];

int lowbit(int x){
    return x&(-x);
}

bool cmp(shu a,shu b)
{
    return a.y<b.y;
}

void in(int x){
    for(;x<=yy;x+=lowbit(x))
    bit[x]++;
}

void out(int x){
    for(;x<=yy;x+=lowbit(x))
    bit[x]--;
}

int find(int x,int k){
    if(vis[x]==k) return w[x];
    vis[x]=k;w[x]=bit[x]+find(x-lowbit(x),k);
    return w[x];
}

int main()
{
    //freopen("gold.in","r",stdin);
    //freopen("gold.out","w",stdout);
    scanf("%d%d%d",&x1,&y1,&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&a[i].x,&a[i].y);
        bx[i]=a[i].x,by[i]=a[i].y;
    }
    sort(a+1,a+1+n);
    sort(bx+1,bx+1+n);
    sort(by+1,by+1+n);
    for(int i=2;i<=n;i++) 
    {
        if(bx[i]!=bx[i-1]) bx[++xx]=bx[i];
        if(by[i]!=by[i-1]) by[++yy]=by[i];
    }
    for(int i=1;i<=n;i++)
    {
        a[i].x=lower_bound(bx+1,bx+1+xx,a[i].x)-bx;
        b[i]=upper_bound(by+1,by+1+yy,a[i].y+y1)-by;
        a[i].y=lower_bound(by+1,by+1+yy,a[i].y)-by;
        b[i]--;
    }

    int l=1,r=1,ans=0,t1,t2,i,k;
    for(k=1;k<=xx;k++)
    {
        while(r<=n&&bx[a[r].x]<=bx[k]+x1)
        {
            in(a[r].y);
            out(b[r]+1);
            r++;
        }
        if(r-l+1>ans) 
        for(i=l;i<=r;i++)
        {
            if(vis[b[i]]==k) t1=w[b[i]];
            else t1=find(b[i],k),w[b[i]]=t1,vis[b[i]]=k;
            ans=max(ans,t1);
        }

        if(r>n) break;
        while(a[l].x==k)
        {
            in(b[l]+1);
            out(a[l].y);
            l++;
        }
    }
    cout<<ans;
    return 0;
}