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=; _T fh=; char c=getchar();
     while(c<''||c>''){ if(c=='-') fh=-; c=getchar(); }
     while(c>=''&&c<=''){ ret=ret*+c-''; c=getchar(); }
     ret=ret*fh;
 }

 struct SEG{
 int ls[N1*],rs[N1*],sz[N1*],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)>>;
     if(x<=mid) upd(x,l,mid,ls[rt1],ls[rt2],w);
     else upd(x,mid+,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)>>,ans=;
     if(L<=mid) ans+=query(L,R,l,mid,ls[rt1],ls[rt2]);
     if(R>mid) ans+=query(L,R,mid+,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 ; int i,ans=;
     for(i=x;i>;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=;
     scanf("%d",&n);
     for(i=;i<=n;i++) read(a[i]), b[i]=a[i];
     sort(b+,b+n+); m=unique(b+,b+n+)-(b+);
     for(i=;i<=n;i++) a[i]=lower_bound(b+,b+m+,a[i])-b;
     for(i=;i<=n;i++) s.upd(a[i],,m,s.root[i-],s.root[i],);

     sq=;
     for(i=;i<=n;i++) pie[i]=(i-)/sq+, ed[pie[i]]=i;
     for(i=;i<=pie[n];i++) st[i]=(i-)*sq+;
     for(i=;i<=n;i++)
     {
         if(a[i]<m)
         {
             for(j=;j<pie[i];j++)
                 f[i][j]=s.query(a[i]+,m,,m,s.root[st[j]-],s.root[i-]);
             f[i][]=s.query(a[i]+,m,,m,s.root[st[pie[i]]-],s.root[i-]);
         }
         if(a[i]>)
         {
             for(j=pie[i];j<=pie[n];j++)
             {
                 f[i][j]=s.query(,a[i]-,,m,s.root[i],s.root[ed[j]]);
                 g[pie[i]][j]+=f[i][j];
             }
         }
     }
     for(j=;j<=pie[n];j++)
     for(i=;i+j<=pie[n];i++)
         g[i][i+j]+=g[i+][i+j];

     scanf("%d",&Q);
     for(q=;q<=Q;q++)
     {
         read(x); read(y); x^=ans; y^=ans; ans=; px=pie[x]; py=pie[y];
         if(px!=py){
             if(px+<=py-) ans=g[px+][py-];
             for(i=x;i<=ed[px];i++) ans+=f[i][py-];
             if(px+==py){
                 for(i=st[py];i<=y;i++) ans+=f[i][];
             }else{
                 for(i=st[py];i<=y;i++) ans+=f[i][px+];
             }
             for(i=st[py];i<=y;i++) bit.upd(a[i],);
             for(i=x;i<=ed[px];i++) if(a[i]>) ans+=bit.query(a[i]-);
             for(i=st[py];i<=y;i++) bit.upd(a[i],-);
         }else{
             for(i=y;i>=x;i--)
             {
                 if(a[i]>) ans+=bit.query(a[i]-);
                 bit.upd(a[i],);
             }
             for(i=x;i<=y;i++) bit.upd(a[i],-);
         }
         printf("%u\n",ans);
     }
     return ;
 }