树状数组看似神奇的应用，求逆序对，离散和非离散

最近学了一些看似玄学的算法，之所以说玄学是因为我太蒟蒻了。首先来说说求逆序对，经典的归并排序方法就不谈了，这里来谈谈树状数组求逆序对。

首先看看这份代码

#include<iostream>
#include<algorithm>
using namespace std;
int a[100000];
int c[100000];
int n;
int lowbit(int x){
    return x&(-x);
}
void add(int i,int v){
    while(i<=n){
        c[i]+=v;
        i+=lowbit(i);
    }
}
int sum(int i){
    int res=0;
    while(i){
        res+=c[i];
        i-=lowbit(i);
    }
    return res;
}
int main(){
    cin>>n;
    int maxnum=0;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        maxnum=max(maxnum,a[i]);
    }
    int ans=0;
    for(int i=1;i<=n;i++){
        ans+=sum(maxnum)-sum(a[i]);
        add(a[i],1);
    }
    cout<<ans<<endl;
    return 0;
}

这份代码如果你上洛谷交的话，恭喜你，得了0分

首先这份代码正确性是对的，可是由于每个元素可能过大，然后就数组越界了，尴尬。。

那么，最近学到了一种巧妙又看似装逼的方法

数组离散化

说白了就是把原来一串数字，从小到大排序后在把自己的排名填到原来的位置上。举个例子

数组a=[1,3,3,4,1,2,5,6,4,8,9]

把他排序后变成

a=[1,1,2,3,3,4,4,5,6,8,9]

每个元素对应原来序列的排名是

b=[1,4,5,6,2,3,8,9,7,10,11]

这里可能如果元素一样并没有对应着排名，可是先后顺序不影响

然后就可以利用这个来求逆序对了

模板

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=500005;
struct node{
    int i,v;
    bool operator < (const node& other)const{
        return v<other.v;
    }
};
node a[maxn];
int b[maxn];
int n;
int c[maxn];
int sum(int i){
    int res=0;
    while(i){
        res+=c[i];
        i-=(i&(-i));
    }
    return res;
}
void add(int i,int v){
    while(i<=n){
        c[i]+=v;
        i+=(i&(-i));
    }
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i].v;
        a[i].i=i;
    }
    sort(a+1,a+1+n);
    for(int i=1;i<=n;i++){
        b[a[i].i]=i;
    }
    int ans=0;
    for(int i=1;i<=n;i++){
        ans+=sum(n)-sum(b[i]);
        add(b[i],1);
    }
    cout<<ans<<endl;
    return 0;
}

当初理解了好久，可以参照最上面的