hdu 5273 Dylans loves sequence(区间逆序对数-莫队算法)

n<=1000,q<=100000,求区间内逆序对数，从[l,r]显然可以log(n)的时间内移动到[l-1,r],[l+1,r],[l,r-1],[l,r+1],那么就可以用莫队进行离线

复杂度大概是O(n*sqrt(n)*log2(n))，不过可以暴力枚举起点，然后向后统计，然后O(1)回答,不过n再大就无法解决了，这个即使是n<=1e5也可以很快得到答案，开-o优化，1e6也可以很快得到答案

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
const int maxm=1e5+5;
/*
    数范围比较大，离散化为[1,n]就好了
    数只有1000个，q次查询[l,r]之间的逆序对数
    如果[l,r]来求[l,r+1] 或[l,r-1]，只要统计a[i]的贡献就好了
    a[i]的贡献可以通过查询树状数组log2(1000)的时间内得到
    这种性质正适合莫队算法，总体复杂度O(n*sqrt(n)*log2(n)+q)
    可以很快的得到答案
    即使n<=1e5，也可以快速得到答案
*/

void jia(int x){
    printf("add %d
",x);
}

void jian(int x){
    printf("-- %d
",x);
}

void read(int &res){
    char c=getchar();
    while(!isdigit(c))c=getchar();
    res=0;
    while(isdigit(c))res=res*10+c-'0',c=getchar();
}
int a[maxn],b[maxn],c[maxn],d[maxn];
int n,q,block;
int ql[maxm],qr[maxm],qq[maxm],ans[maxm];

inline int lowbit(int x){return x&(-x);}
bool cmp1(int i,int j){return a[i]<a[j];}
void add(int x,int val){
    //if(val>0)jia(x);else jian(x);
    while(x<=n)c[x]+=val,x+=lowbit(x);
}
int query(int x){
    int res=0;
    while(x>0)res+=c[x],x-=lowbit(x);
    return res;
}

bool cmp2(int i,int j){
    int q1=ql[i]/block;
    int q2=ql[j]/block;
    if(q1!=q2)return q1<q2;
    if(qr[i]!=qr[j])return qr[i]<qr[j];
    return qr[i]<qr[j];
}

int main(){

    freopen("in","r",stdin);
    freopen("wa","w",stdout);

    read(n);read(q);
    block=sqrt(n);

    for(int i=1;i<=n;i++)read(a[i]),b[i]=i;
    sort(b+1,b+1+n,cmp1);

    int tot=0,last=-1;

    for(int i=1;i<=n;i++){
        if(a[b[i]]==last)d[b[i]]=tot;
        else d[b[i]]=++tot,last=a[b[i]];
    }

    for(int i=0;i<q;i++)read(ql[i]),read(qr[i]),qq[i]=i;
    sort(qq,qq+q,cmp2);

    int l=1,r=1,res=0;
    add(d[1],1);
    for(int i=0;i<q;i++){
        int L=ql[qq[i]],R=qr[qq[i]];
        while(r<R){
            res+=r-l+1-query(d[r+1]);
            add(d[r+1],1);
            r++;
        }
        while(r>R){
            res-=r-l+1-query(d[r]);
            add(d[r],-1);
            r--;
        }
        while(l<L){
            res-=query(d[l]-1);
            add(d[l],-1);
            l++;
        }
        while(l>L){
            res+=query(d[l-1]-1);
            add(d[l-1],1);
            l--;
        }
        ans[qq[i]]=res;
    }
    for(int i=0;i<q;i++)
        printf("%d
",ans[i]);

    return 0;
}