[BZOJ]3110 K大数查询(ZJOI2013)

  这大概是唯一一道小C重写了4次的题目。

  姿势不对的树套树(Fail) → 分块(Fail) → 整体二分(Succeed) → 树套树(Succeed)。

  让小C写点心得静静。

 

Description

  有N个位置,M个操作。操作有两种,每次操作如果是1 a b c的形式表示在第a个位置到第b个位置,每个位置加入一个数c。如果是2 a b c形式,表示询问从第a个位置到第b个位置,第C大的数是多少。

Input

  第一行N,M。
  接下来M行,每行形如1 a b c或2 a b c。

Output

  输出每个询问的结果

Sample Input

  2 5
  1 1 2 1
  1 1 2 2
  2 1 1 2
  2 1 1 1
  2 1 2 3

Sample Output

  1
  2
  1

HINT

  N,M<=50000,N,M<=50000
  a<=b<=N
  1操作中abs(c)<=N
  2操作中c<=Maxlongint

 

Solution

  这道题让小C见识了整体二分的妙用,它是一种离线做法。

  整体二分的思想就是二分答案。以单次询问的区间K大为例,我们可以二分答案,通过统计比当前二分出的答案大的数的个数,与K比较,决定缩小或是增大答案。

  而对于多次询问,我们整体二分所有询问的答案,对于每个询问,我们都通过比较,来决定它们应该进入小的那一半,还是大的那一半。

  而对于每个修改,我们也要判断它会对哪个区间的答案产生影响,来决定它应该进入哪一半。

  要注意,任何时候,每个询问和修改之间的相对顺序都不能变。

  这样的时间复杂度为什么是科学的呢?我们脑补一下:

    

  动态询问的本质就是边修改边询问的过程,对于每次修改,我们用数据结构维护要统计的信息。(这是一句废话)

  因为有数据结构的存在,时间复杂度才是科学的。(还不理解的读者请将这一行无视,继续往下看)

  What?还需要数据结构?那我要整体二分何用?我咋不大力树套树呢?

  整体二分当然不是白写的。原来树套树要维护的是,值域区间[L,R]内,数组的信息,需要二维。

  而整体二分时,我们只需要维护 当前 二分的值域区间[L,R]内,数组的信息,只需要一维。

  因为做完 当前 这段值域区间内的事情后,这棵线段树/平衡树就彻底没用了,因为关于它的所有事情都做完了,清空就行。(理解了再往下看吧)

  这就巧妙利用离线做法将数据结构降维,空间和时间(常数)上都有很大的提升。

  最后证明一下时间复杂度:对于每个询问和修改,我们都在二分答案的 log 个区间内做了一遍,总时间复杂度

  当然具体实现还有一些细节,还不理解的可以参见小C的代码。

 

  说说这道题的题解:

    树套树:以值域为第一维,以数组下标为第二维,第二维维护区间和。对于每个询问,像二分答案一样在第一维上走到底。

    整体二分:离线,把树套树做法降维。

 

  整体二分:

#include <cstdio>
#include <cstring>
#include <algorithm>
#define l(a) son[a][0]
#define r(a) son[a][1]
#define MN 50005
#define ll long long
using namespace std;
struct meg{int g,x,y,z,pos,gs;}q[MN],q1[MN],q2[MN];
int son[MN<<2][2],tg[MN<<2],din,rt;
int ans[MN],n,m,ain;
ll t[MN<<2];

inline int read()
{
    int n=0,f=1; char c=getchar();
    while (c<'0' || c>'9') {if(c=='-')f=-1; c=getchar();}
    while (c>='0' && c<='9') {n=n*10+c-'0'; c=getchar();}
    return n*f;
}

inline void mark(int &x,int L,int R,int z)
{
    if (!x) {x=++din; l(x)=r(x)=t[x]=tg[x]=0;}
    t[x]+=1LL*z*(R-L+1); tg[x]+=z;
}
inline void down(int x,int L,int R)
{
    if (!tg[x]) return;
    int mid=L+R>>1;
    mark(l(x),L,mid,tg[x]); mark(r(x),mid+1,R,tg[x]);
    tg[x]=0;
}

ll getsum(int x,int L,int R,int ql,int qr)
{
    if (!x) return 0;
    if (ql==L&&qr==R) return t[x];
    down(x,L,R);
    int mid=L+R>>1;
    if (qr<=mid) return getsum(l(x),L,mid,ql,qr);
    else if (ql>mid) return getsum(r(x),mid+1,R,ql,qr);
    else return getsum(l(x),L,mid,ql,mid)+getsum(r(x),mid+1,R,mid+1,qr);
}
void add(int &x,int L,int R,int ql,int qr)
{
    if (!x) {x=++din; l(x)=r(x)=t[x]=tg[x]=0;}
    if (ql==L&&qr==R) {mark(x,ql,qr,1); return;}
    down(x,L,R);
    int mid=L+R>>1;
    if (qr<=mid) add(l(x),L,mid,ql,qr);
    else if (ql>mid) add(r(x),mid+1,R,ql,qr);
    else add(l(x),L,mid,ql,mid),add(r(x),mid+1,R,mid+1,qr);
    t[x]=t[l(x)]+t[r(x)];
}

void work(int L,int R,int hd,int tl)
{
    if (hd>tl) return;
    register int i;
    if (L==R) {for (i=hd;i<=tl;++i) if (q[i].g==2) ans[q[i].pos]=L; return;}
    int mid=L+R>>1,p1=0,p2=0;
    ll lt;
    rt=din=0;
    for (i=hd;i<=tl;++i)
    {
        if (q[i].g==1)
        {
            if (q[i].z>mid) add(rt,1,n,q[i].x,q[i].y),q2[++p2]=q[i];
            else q1[++p1]=q[i];
        }
        else if (q[i].g==2)
        {
            lt=getsum(rt,1,n,q[i].x,q[i].y);
            if (lt+q[i].gs>=q[i].z) q2[++p2]=q[i];
            else q[i].gs+=lt,q1[++p1]=q[i];
        }
    }
    for (i=1;i<=p1;++i) q[hd+i-1]=q1[i];
    for (i=1;i<=p2;++i) q[hd+p1+i-1]=q2[i];
    work(L,mid,hd,hd+p1-1); work(mid+1,R,hd+p1,tl);
}

int main()
{
    register int i;
    n=read(); m=read();
    for (i=1;i<=m;++i) {q[i].g=read(); q[i].x=read(); q[i].y=read(); q[i].z=read(); if (q[i].g==2) q[i].pos=++ain;}
    work(-n,n,1,m);
    for (i=1;i<=ain;++i) printf("%d\n",ans[i]);
}

 

  树套树:

#include <cstdio>
#include <cstring>
#include <algorithm>
#define l(a) (a<<1)
#define r(a) (a<<1|1)
#define L(a) (son[a][0])
#define R(a) (son[a][1])
#define TMN 15000005
#define MN 50005
#define ll long long
using namespace std;
ll t[TMN];
int son[TMN][2],tg[TMN],rt[MN<<3],din;
int n,m;

inline int read()
{
    int n=0,f=1; char c=getchar();
    while (c<'0' || c>'9') {if(c=='-')f=-1; c=getchar();}
    while (c>='0' && c<='9') {n=n*10+c-'0'; c=getchar();}
    return n*f;
}

ll Tgetsum(int x,int L,int R,int ql,int qr)
{
    if (!x) return 0;
    if (ql==L&&qr==R) return t[x];
    int mid=L+R>>1;
    ll lt=1LL*tg[x]*(qr-ql+1);
    if (qr<=mid) return lt+Tgetsum(L(x),L,mid,ql,qr);
    else if (ql>mid) return lt+Tgetsum(R(x),mid+1,R,ql,qr);
    else return lt+Tgetsum(L(x),L,mid,ql,mid)+Tgetsum(R(x),mid+1,R,mid+1,qr);
}
void Tadd(int &x,int L,int R,int ql,int qr)
{
    if (!x) x=++din;
    if (ql==L&&qr==R) {++tg[x]; t[x]+=(ll)R-L+1; return;}
    int mid=L+R>>1;
    if (qr<=mid) Tadd(L(x),L,mid,ql,qr);
    else if (ql>mid) Tadd(R(x),mid+1,R,ql,qr);
    else Tadd(L(x),L,mid,ql,mid),Tadd(R(x),mid+1,R,mid+1,qr);
    t[x]=t[L(x)]+t[R(x)]+1LL*tg[x]*(R-L+1);
}

int getk(int x,int L,int R,int z,int yl,int yr)
{
    if (L==R) return L;
    ll lt;
    int mid=L+R>>1;
    if ((lt=Tgetsum(rt[r(x)],1,n,yl,yr))<z) return getk(l(x),L,mid,z-lt,yl,yr);
    else return getk(r(x),mid+1,R,z,yl,yr);
}
void add(int x,int L,int R,int q,int yl,int yr)
{
    Tadd(rt[x],1,n,yl,yr);
    if (L==R) return;
    int mid=L+R>>1;
    if (q<=mid) add(l(x),L,mid,q,yl,yr);
    else add(r(x),mid+1,R,q,yl,yr);
}

int main()
{
    register int g,x,y,z;
    n=read(); m=read();
    while (m--)
    {
        g=read(); x=read(); y=read(); z=read();
        if (g==1) add(1,-n,n,z,x,y);
        else if (g==2) printf("%d\n",getk(1,-n,n,z,x,y));
    }
}

 

Last Word

  说说前两次打这题的惨痛经历吧:

  第一次树套树把(相对于正解)第一维和第二维搞反了,导致空间爆炸。

  第二次分块,脑补了一个时间和空间都是O(n*sqrt(n)*log(n))的做法(权值线段树+替罪羊树瞎写),空间还是爆炸。

  两次做法的思路都是二分答案,而且都把数组下标看作是第一维。

  不过所幸打的这几次都没怎么需要Debug。打得挺爽。

posted @ 2017-07-04 09:38  ACMLCZH  阅读(207)  评论(0编辑  收藏  举报