[bzoj3787]Gty的文艺妹子序列

题目大意

在线兹瓷修改操作与区间求逆序对。
所有元素大小在[1,n]

很显然的离线做法

我们回忆bzoj3289的做法，可以使用莫队算法，加上线段树进行兹瓷in，out，query。

在线做法？

我们回忆经典分块做法。
预处理ans[i,j]表示第i块到第j块的答案，sum[i,j]表示前i块元素j的个数，然后只需要再弄个树状数组就可以搞了。
现在我们要兹瓷修改，那我们照着原来的思路改一下。
ans[i,j]表示在第i块取一个元素并在第j块取一个元素组成的逆序对个数。
那么每次修改操作会涉及到根号个值发生改变，询问操作时需要对第二维进行区间查询。因此第二维用树状数组维护。
sum[i,j]表示前i块元素j的个数，那么修改操作也只会改变根号个值，询问操作需要对第二维进行区间查询，因此第二维用树状数组维护。
num[i]表示第i块内逆序对个数，修改操作暴力重算。
因此就可以了。

温馨提示：用线段树会TLE的很惨哦！

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<ctime>
#define fo(i,a,b) for(i=a;i<=b;i++)
#define fd(i,a,b) for(i=a;i>=b;i--)
using namespace std;
const int maxn=50000+10,maxc=250+10;
int ans[maxc][maxc],num[maxc];
int sum[maxc][maxn],tree[maxn];
int belong[maxn],a[maxn],sta[maxn];
int i,j,k,l,r,s,t,n,m,now,top,c;
bool czy;
int lowbit(int x){
    return x&-x;
}
void change(int k,int t){
    while(k<=n){  
        tree[k]+=t;  
        k+=lowbit(k);  
    }  
}
int query(int k){
    int t=0;  
    while (k){  
        t+=tree[k];  
        k-=lowbit(k);  
    }  
    return t;  
}
void change2(int id,int k,int t){
    while(k<=belong[n]){  
        ans[id][k]+=t;  
        k+=lowbit(k);  
    }  
}
int query2(int id,int k){
    int t=0;  
    while (k){  
        t+=ans[id][k];  
        k-=lowbit(k);  
    }  
    return t;  
}
void change3(int id,int k,int t){
    while(k<=n){  
        sum[id][k]+=t;  
        k+=lowbit(k);  
    }  
}
int query3(int id,int k){
    int t=0;  
    while (k){  
        t+=sum[id][k];  
        k-=lowbit(k);  
    }  
    return t;  
}
int read(){
    int x=0;
    char ch=getchar();
    while (ch<'0'||ch>'9') ch=getchar();
    while (ch>='0'&&ch<='9'){
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x;
}
void write(int x){
    while (x){
        sta[++top]=x%10;
        x/=10;
    }
    while (top){
        putchar(sta[top]+'0');
        top--;
    }
    putchar('\n');
}
int main(){
    //freopen("data6.in","r",stdin);freopen("3787.out","w",stdout);
    czy=1;
    n=read();
    c=floor(sqrt(n));
    fo(i,1,n) a[i]=read(),belong[i]=(i-1)/c+1;
    fo(i,1,belong[n]-1){
        fo(j,(i-1)*c+1,i*c) change(a[j],1);
        fo(j,i+1,belong[n]){
            t=0;
            fo(k,(j-1)*c+1,min(j*c,n)) t+=query(n)-query(a[k]);
            change2(i,j,t);
        }
        fo(j,(i-1)*c+1,i*c) change(a[j],-1);
    }
    fo(i,1,belong[n])
        fo(j,1,min(i*c,n)) change3(i,a[j],1);
    fo(i,1,belong[n]){
        fo(j,(i-1)*c+1,min(n,i*c)){
            num[i]+=query(n)-query(a[j]);
            change(a[j],1);
        }
        fo(j,(i-1)*c+1,min(n,i*c)) change(a[j],-1);
    }
    m=read();
    while (m--){
        t=read();
        if (t==0){
            j=read();k=read();
            if (czy) j^=now,k^=now;
            now=0;
            l=belong[j];r=belong[k];
            if (r-l<=1){
                fo(i,j,k){
                    now+=query(n)-query(a[i]);
                    change(a[i],1);
                }
                fo(i,j,k) change(a[i],-1);
                //write(now);
                printf("%d\n",now);
                continue;
            }
            fo(i,l+1,r-1){
                now+=num[i];
                now+=query2(i,r-1)-query2(i,i);
            }
            fo(i,j,l*c){
                now+=query(n)-query(a[i]);
                now+=query3(r-1,a[i]-1)-query3(l,a[i]-1);
                change(a[i],1);
            }
            fo(i,(r-1)*c+1,k){
                now+=query(n)-query(a[i]);
                now+=query3(r-1,n)-query3(r-1,a[i])-query3(l,n)+query3(l,a[i]);
                change(a[i],1);
            }
            fo(i,j,l*c) change(a[i],-1);
            fo(i,(r-1)*c+1,k) change(a[i],-1);
            //write(now);
            printf("%d\n",now);
        }
        else{
            j=read();k=read();
            if (czy) j^=now,k^=now;
            fo(i,belong[j]+1,belong[n]){
                t=query3(i,k-1)-query3(i-1,k-1);
                t-=query3(i,a[j]-1)-query3(i-1,a[j]-1);
                change2(belong[j],i,t);
            }
            fo(i,1,belong[j]-1){
                t=query3(i,n)-query3(i,k)-query3(i-1,n)+query3(i-1,k);
                t-=query3(i,n)-query3(i,a[j])-query3(i-1,n)+query3(i-1,a[j]);
                change2(i,belong[j],t);
            }
            fo(i,belong[j],belong[n]){
                change3(i,a[j],-1);
                change3(i,k,1);
            }
            a[j]=k;
            num[belong[j]]=0;
            fo(i,(belong[j]-1)*c+1,min(belong[j]*c,n)){
                num[belong[j]]+=query(n)-query(a[i]);
                change(a[i],1);
            }
            fo(i,(belong[j]-1)*c+1,min(belong[j]*c,n)) change(a[i],-1);
        }
    }
    //printf("\n%d\n",clock());
}