BZOJ 3744 Gty的妹子序列 (分块+树状数组+主席树)

题面传送门

题目大意：给你一个序列，多次询问，每次取出一段连续的子序列$[l,r]$，询问这段子序列的逆序对个数，强制在线

 

很熟悉的分块套路啊，和很多可持久化01Trie的题目类似，用分块预处理出贡献，而这道题是用可持久化线段树罢了

首先对序列分块，设块大小为$S$

再建出主席树，我们就能在$O(logn)$时间内查询某个点$i$与区间$[l,r]$内的点产生的逆序对数量

然后处理出点和整块之间的答案，设$f(i,j)$表示第$i$个点与第$j$块的开始/末尾这段区间内的点产生的逆序对数量。

再根据 点到块的答案 统计出 块到块的答案

对于每次询问，利用预处理出的东西$O(1)$搞出 整块到整块 的贡献，再暴力枚举边角+主席树查询搞出 边角到整块 和 边角到边角 的贡献。

然后就会被卡常

我们可以用树状数组搞出 边角到边角 的贡献，再用预处理的信息搞出 边角对整块 的贡献...

虽然每次查询的时间也是$O(logn)$不变，但非递归的树状数组确实能减少大量的常数 #喷血

分析一下时间复杂度，预处理+查询=O(n\frac{n}{S}logn+QSlogn)，因为预处理是用主席树查询的所以比较慢..块要开大一些

 

#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define N1 50500
#define M1 120
#define ll long long 
#define uint unsigned int 
using namespace std;

template <typename _T> void read(_T &ret)
{
    ret=0; _T fh=1; char c=getchar();
    while(c<'0'||c>'9'){ if(c=='-') fh=-1; c=getchar(); }
    while(c>='0'&&c<='9'){ ret=ret*10+c-'0'; c=getchar(); }
    ret=ret*fh;
}

struct SEG{
int ls[N1*20],rs[N1*20],sz[N1*20],root[N1],tot;
void pushup(int rt){ sz[rt]=sz[ls[rt]]+sz[rs[rt]];  }
void upd(int x,int l,int r,int rt1,int &rt2,int w)
{
    if(!rt2||rt1==rt2){ rt2=++tot; ls[rt2]=ls[rt1]; rs[rt2]=rs[rt1]; sz[rt2]=sz[rt1]; }
    if(l==r){ sz[rt2]+=w; return; }
    int mid=(l+r)>>1;
    if(x<=mid) upd(x,l,mid,ls[rt1],ls[rt2],w);
    else upd(x,mid+1,r,rs[rt1],rs[rt2],w);
    pushup(rt2);
}
int query(int L,int R,int l,int r,int rt1,int rt2)
{
    if(L<=l&&r<=R) return sz[rt2]-sz[rt1];
    int mid=(l+r)>>1,ans=0;
    if(L<=mid) ans+=query(L,R,l,mid,ls[rt1],ls[rt2]);
    if(R>mid) ans+=query(L,R,mid+1,r,rs[rt1],rs[rt2]);
    return ans;
}
}s;


int n,m,sq,Q,de;

struct BIT{
int sum[N1];
int upd(int x,int w)
{
    int i;
    for(i=x;i<=m;i+=(i&(-i)))
        sum[i]+=w;
}
int query(int x)
{
    if(!x) return 0; int i,ans=0; 
    for(i=x;i>0;i-=(i&(-i)))
        ans+=sum[i];
    return ans;
}
}bit;

int a[N1],b[N1],pie[N1],st[M1],ed[M1];
uint f[N1][M1],g[M1][M1];

int main()
{
    int i,j,k,l,r,q,x,y,px,py; uint ans=0;
    scanf("%d",&n);
    for(i=1;i<=n;i++) read(a[i]), b[i]=a[i];
    sort(b+1,b+n+1); m=unique(b+1,b+n+1)-(b+1);
    for(i=1;i<=n;i++) a[i]=lower_bound(b+1,b+m+1,a[i])-b;
    for(i=1;i<=n;i++) s.upd(a[i],1,m,s.root[i-1],s.root[i],1);
    
    sq=450;
    for(i=1;i<=n;i++) pie[i]=(i-1)/sq+1, ed[pie[i]]=i;
    for(i=1;i<=pie[n];i++) st[i]=(i-1)*sq+1;
    for(i=1;i<=n;i++)
    {
        if(a[i]<m)
        {
            for(j=1;j<pie[i];j++)
                f[i][j]=s.query(a[i]+1,m,1,m,s.root[st[j]-1],s.root[i-1]);
            f[i][0]=s.query(a[i]+1,m,1,m,s.root[st[pie[i]]-1],s.root[i-1]);
        }
        if(a[i]>1)
        {
            for(j=pie[i];j<=pie[n];j++)
            {
                f[i][j]=s.query(1,a[i]-1,1,m,s.root[i],s.root[ed[j]]);
                g[pie[i]][j]+=f[i][j];
            }
        }
    }
    for(j=1;j<=pie[n];j++)
    for(i=1;i+j<=pie[n];i++)
        g[i][i+j]+=g[i+1][i+j];
    
    scanf("%d",&Q);
    for(q=1;q<=Q;q++)
    {
        read(x); read(y); x^=ans; y^=ans; ans=0; px=pie[x]; py=pie[y];
        if(px!=py){
            if(px+1<=py-1) ans=g[px+1][py-1];
            for(i=x;i<=ed[px];i++) ans+=f[i][py-1];
            if(px+1==py){ 
                for(i=st[py];i<=y;i++) ans+=f[i][0];
            }else{ 
                for(i=st[py];i<=y;i++) ans+=f[i][px+1]; 
            }
            for(i=st[py];i<=y;i++) bit.upd(a[i],1);
            for(i=x;i<=ed[px];i++) if(a[i]>1) ans+=bit.query(a[i]-1); 
            for(i=st[py];i<=y;i++) bit.upd(a[i],-1);
        }else{
            for(i=y;i>=x;i--) 
            {
                if(a[i]>1) ans+=bit.query(a[i]-1);
                bit.upd(a[i],1);
            }
            for(i=x;i<=y;i++) bit.upd(a[i],-1);
        }
        printf("%u\n",ans);
    }
    return 0;
}