用树状数组处理逆序对[数据结构][树状数组]

逆序对

——!x^n+y^n=z^n

　　可以到这里[luogu]：

_{https://www.luogu.org/problem/show?pid=1908}

题意：对于给定的一段正整数序列，逆序对就是序列中ai>aj且i<j的有序对。知道这概念后，他们就比赛谁先算出给定的一段正整数序列中逆序对的数目。

　　假如为这些数为：

8 2 3 1 7

　　如果我们把数一个个加进来，用一个数组a[i]统计i出现了几次。

a的初始状态：

 

8加进来后：

由于不存在比8大的数，说明没有产生逆序对

2加进来后：

统计比2大的数（即产生逆序对），有一个

3加进来后：

逆序对+1

...

　　可能大家都看出来了，即每次加入统计前面的数有几个比自己大，即统计后面的数有几个，这种事情当然用树状数组操作很方便。

　　其实如果大家在想一想，如果我把这些数倒过来看，那我们就是要统计前面有几个数比自己小，这不就和树状数组操作一模一样？

　　当然在进行上述操作可能就看出问题了，就是4,5,6这些是没用的，这样不仅费时还费空间。

　　其实上面的数和

5 2 3 1 4 的逆序对数是一样的，这样我们的操作就完美了。（当然你要主要有几个数是一样的情况）

附上Lowbee的代码

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define maxn 100010
struct lys{
    int pos,v;
}p[maxn];
int bit[maxn],a[maxn];
inline int read();
namespace Liisa{
    int n;
    int lowbit(int x){
        return x&(-x);
    }
    bool cmp(const lys &a,const lys &b){
        return a.v<b.v;
    }
    //插入，或者理解为单点更新 
    void insert(int x){
        int i;
        for(i=x;i<=n;i+=lowbit(i))
            bit[i]++;
    }
    //统计和 
    long long getsum(int x){
        int i;
        long long res=0;
        for(i=x;i>0;i-=lowbit(i))
            res+=bit[i];
        return res;
    }
    long long ans=0;
    int main(){
        n=read();
        int i;
        for(i=1;i<=n;i++){
            p[i].pos=i; p[i].v=read();
        }
        sort(p+1,p+1+n,cmp);
        int s=0;
        p[0].v=-1;
        //离散化操作 
        for(i=1;i<=n;i++){
            if(p[i].v!=p[i-1].v) s++;
            a[p[i].pos]=s;
        }
        //计算逆序对，从后往前读 
        for(i=n;i>=1;i--){
            insert(a[i]);
            //统计比自己小的 
            ans+=getsum(a[i]-1);
        }
        cout<<ans<<endl;
    }
}
int main(){
    Liisa::main();
    return 0;
}
inline int read(){
    int k=0,f=1;
    char c=getchar();
    while(c>'9'||c<'0'){
        if(c=='-') f=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9'){
        k=k*10+c-'0';
        c=getchar();
    }
    return k*f;
}

_{如有错误，欢迎指正。}