[分块] Codeforces 436F && Zepto Code Rush 2014 F. Banners

考虑从大到小枚举c，考虑把bi>=c的人删去，然后就要求一个p使p*x最大，x为满足ai>=p的i的个数。

考虑把1~max(ai)分块，每块可以就出块中的最大值，然后要维护每块答案，当一块内的最大值要变化的时候暴力重构整个块，零碎的也暴力重构，因为快内最大值最多变化块的大小次，所以总复杂度均也就是O(nn√)的。

题解的做法很短，我就没有去实践了……

题解做法可以看这篇

考场上也想到了分块，但是没有仔细分析复杂度，就写了一个O(nn√logn)的，当然可以通过改变块的大小使复杂度变成O(nnlogn−−−−−√)

依然考虑怎么维护每一块，可以发现如果把(i,xi*i)看做一个点（i为原题中的p取的值，xi为ai>=i的个数），那么块内的最大值怎么变都是在上凸包上，每个块维护一下凸包，跟新的时候二分一下就可以了…不过因为答案单调，也可以用单调队列……

但是这个做法应该不需要题答案单调，题解的做法应该只有在答案单调的时候才可以保证复杂度。

然而考场上时间不够有一个细节没调出来……果然代码能力还是不够

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <cmath>
#include <ctime>
#define fi first
#define se second

using namespace std;

typedef long long ll;
typedef pair<ll,ll> par;
typedef pair<ll,par> parr;

const int N=200010,M=1010;

int n,w,block,L,cnt,m1,m2,top;
par a
,Q
,ans
;
int tot[N<<2],p
,d[M];
par b[M][M];int sz[M];
parr v[M][M];int szv[M];

inline char nc(){
static char buf[100000],*p1=buf,*p2=buf;
return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}

inline void rea(int &x){
char c=nc(); x=0;
for(;c>'9'||c<'0';c=nc());for(;c>='0'&&c<='9';x=x*10+c-'0',c=nc());
}

inline void rea(ll &x){
char c=nc(); x=0;
for(;c>'9'||c<'0';c=nc());for(;c>='0'&&c<='9';x=x*10+c-'0',c=nc());
}

void Cover(int g,int l,int r,int L,int R){
if(l==L&&r==R){
tot[g]++; return ;
}
int mid=L+R>>1;
if(r<=mid) Cover(g<<1,l,r,L,mid);
else if(l>mid) Cover(g<<1|1,l,r,mid+1,R);
else Cover(g<<1,l,mid,L,mid),Cover(g<<1|1,mid+1,r,mid+1,R);
}

int Query(int g,int x,int L,int R){
if(L==R) return tot[g];
int mid=L+R>>1;
if(x<=mid) return Query(g<<1,x,L,mid)+tot[g];
else return Query(g<<1|1,x,mid+1,R)+tot[g];
}

par inn[M];

inline void fix(par* ww,parr *outt,int pp){
for(int i=1;i<=sz[pp];i++) inn[i]=ww[i];
sort(inn+1,inn+1+sz[pp]);
p[pp]=1; szv[pp]=0; d[pp]=0;
int t=sz[pp];
while(inn[t].fi==inn[t-1].fi&&t-1>0) t--;
outt[++szv[pp]]=parr(0,inn[t]);
Q[top=1]=inn[t];
long long mn=inn[t].se;
for(int i=t-1;i>0;i--){
if(inn[i].se>=mn) continue;
mn=inn[i].se;
while(top>1&&1LL*(Q[top-1].fi-inn[i].fi)*(Q[top].se-inn[i].se)>=1LL*(Q[top].fi-inn[i].fi)*(Q[top-1].se-inn[i].se)) top--;
outt[++szv[pp]]=parr((ll)ceil((double)(Q[top].fi-inn[i].fi)/(double)(Q[top].se-inn[i].se)),inn[i]);
Q[++top]=inn[i];
}
sort(outt+1,outt+1+szv[pp]);
mn=1LL<<60; t=0;
for(int i=1;i<=szv[pp];i++){
if(v[pp][i].se.fi>=mn) continue;
mn=v[pp][i].se.fi;
v[pp][++t]=v[pp][i];
}
szv[pp]=t;
}

inline void Modify(int l,int r){
for(int i=1;i<r/block+1;i++){
d[i]++;
while(p[i]!=szv[i]&&v[i][p[i]+1].fi<=d[i]) p[i]++;
}
int cur=r/block+1;
for(int i=1;i<=sz[cur];i++)
b[cur][i].fi-=b[cur][i].se*d[cur];
for(int i=1;b[cur][i].se<=r&&i<=sz[cur];i++)
b[cur][i].fi-=b[cur][i].se;
fix(b[cur],v[cur],cur);
}

inline par Check(){
par ret=par(0,0);
for(int i=1;i<=cnt;i++){
ll val=v[i][p[i]].se.fi-1LL*d[i]*v[i][p[i]].se.se;
if(val>ret.fi||(val==ret.fi&&v[i][p[i]].se.se<ret.se))
ret=par(val,v[i][p[i]].se.se);
}
return ret;
}

void Put(ll x){
if(x>=10) Put(x/10);
putchar(x%10+'0');
}

int main(){
rea(n); rea(w);
for(int i=1;i<=n;i++)
rea(a[i].se),rea(a[i].fi),m1=max((int)a[i].se,m1),m2=max((int)a[i].fi,m2);
sort(a+1,a+1+n); block=max((int)sqrt(m1/log2(m1)*2),1); cnt=m1/block+1;
for(int i=1;i<=n;i++)
Cover(1,0,a[i].se,0,m1);
for(int i=0;i<=m1;i++)
b[i/block+1][++sz[i/block+1]]=par(1LL*i*Query(1,i,0,m1),i);
for(int i=1;i<=cnt;i++)
fix(b[i],v[i],i);
int cur=0;
for(int i=m2+1,j=n;~i;i--){
while(j&&a[j].fi>=i)
cur++,Modify(0,a[j].se),j--;
par now=Check();
ans[i]=par(1LL*cur*i*w+now.fi,now.se);
}
for(int i=0;i<=m2+1;i++)
Put(ans[i].fi),putchar(' '),Put(ans[i].se),putchar('\n');
return 0;
}