11.07练习赛

11.07练习题

T1 俄罗斯套娃

太懒了直接搬原题面系列

你开了一家卖俄罗斯套娃的店。因此，你向厂家订购了\(N\)个俄罗斯套娃，这些娃娃被编号为\(1\)到\(N\)，其中第\(i\)个套娃是一个的直径为\(R_i\)高度为\(H_i\)的直♂柱体 。每个俄罗斯套娃都只能套高和直径严格比他小的套娃。同时只要满足条件，俄罗斯套娃可以嵌套多次。
 
有一天，你收到了厂家的来电，告诉你你预定的\(N\)个娃娃不能一次性全部做完。所以第一批只会送达直径大于等于\(A\)并且高度小于等于\(B\)的所有套娃。你需要预先安排出一个方案，使送来的套娃经过若干次嵌套后，没有被套的套娃数量最小。
 
由于厂家经常搞大新闻，所以他会改变\(A\)和\(B\)的值，总共\(Q\)次，因此你需要对每对\((A,B)\)都作出回答，询问之间互不干扰。

详细题面在此

第一眼看二维数点（实为对wangdy大佬给的数星星印象深刻），于是打了一个维护前缀和的。发现爆了。仔细思考后发现是要维护区间最大值（即为统计最多能套多少个套娃进来）。
稍微改了下，过了。交到OJ上，T了。
那咋办嘛

那就只有快读了啊

#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std; 
char *p1,*p2,buf[1<<20]; 
#define GC (p1==p2&&(p1=buf,p2=buf+fread(buf,1,1<<20,stdin),p1==p2)?0:(*(p1++))) 
//#define GC getchar() 
inline int in() 
{ 
    int ans; 
    char t,k; 
    while(((t=GC)!='-'&&(t>'9'||t<'0'))); 
    k=(t=='-'); 
    ans=k?0:(t-'0'); 
    while((t=GC)>='0'&&t<='9')ans=ans*10+t-'0'; 
    return k?-ans:ans; 
}
struct node{
    int r,h;
    int id;
}g[500010],qu[500010];
inline int lowbit(int x){return x&(-x);}
int ans[500010];
int Hs[500010];
bool cmp1(node a,node b){
    return a.h<b.h;
}
bool cmp2(node a,node b)
{
    return a.r<b.r;
}
bool cmp(node a,node b)
{
    if(a.r!=b.r){
        return a.r>b.r;
    }
    return a.h<b.h;
}
int n,q;
int sum[500010];
int gs(int x)
{
    int res=0;
    for(;x;x-=lowbit(x)){
        res=max(res,sum[x]);
    }
    return res;
}
void ins(int x,int k){
    for(;x<=n+q;x+=lowbit(x)){
        sum[x]=max(sum[x],k);
    }
    return;
}
int qh[500010],cnt;//改了半天发现两个东西都要离散化…… 
int main()
{
//  freopen("matryoshka.in","r",stdin);
//  freopen("matryoshka.out","w",stdout);
    n=in();q=in();
    int i,j;
    for(i=1;i<=n;i++)
    {
        g[i].r=in();g[i].h=in();
        qh[++cnt]=g[i].h;
    }
    for(i=1;i<=q;i++)
    {
        qu[i].r=in();qu[i].h=in();
        qu[i].id=i;
        qh[++cnt]=qu[i].h;
    }
    sort(qh+1,qh+cnt+1);
    int cnth=0;
    for(i=1;i<=cnt;i++){
        if(qh[i]!=qh[i-1]){
            Hs[++cnth]=qh[i];
        }
    }
    sort(g+1,g+1+n,cmp);
    sort(qu+1,qu+1+q,cmp);
    j=1;
    for(i=1;i<=q;i++)
    {
        while(g[j].r>=qu[i].r&&j<=n){
            int v=lower_bound(Hs+1,Hs+cnth+1,g[j].h)-Hs;
            ins(v,1+gs(v));
            j+=1;
        }
        int p=lower_bound(Hs+1,Hs+cnth+1,qu[i].h)-Hs;
        ans[qu[i].id]=gs(p);
    }
    for(i=1;i<=q;i++){
        printf("%d\n",ans[i]);
    }
    return 0;
}

(注：程序里对于询问操作里\(H\)(即\(B\))值的离散化似乎可以把\(lower\_bound\)改成\(upper\_bound\)优化掉。估计TLE就是因为这个）