逆序对

逆序对

n（1<=n<=100000）个数，输出其中逆序对的对数。

输入：

5
2 3 1 5 4

输出：

3

离散化+树状数组

代码：

#include <bits/stdc++.h>
const int MAXN=1000;
using namespace std;

struct node{
    long long v;
    int id;
    bool operator <(const node&p) const{
        return v<p.v;
    }
};
node a[MAXN+10];
long long c[MAXN+10];
long long b[MAXN+10];
int n;

inline int lowbit(int x){
    return x&-x;
}

long long Query(int x){
    long long ans=0;
    while(x){
        ans+=c[x];
        x-=lowbit(x);
    }
    return ans;
}

void Change(int x){
    while(x<=n){
        c[x]++;
        x+=lowbit(x);
    }
}

void printA(){
    cout<<"a数组"<<endl;
    cout<<setw(7)<<"id:"<<" "; 
    for(int i=1;i<=n;i++){
        cout<<a[i].id<<" ";
    }
    cout<<endl;
    cout<<setw(7)<<"value:"<<" "; 
    for(int i=1;i<=n;i++){
        cout<<a[i].v<<" ";
    }
    cout<<endl;
} 

void printB(){
    cout<<"b数组"<<endl;
    cout<<setw(7)<<"b[i]:"<<" "; 
    for(int i=1;i<=n;i++){
        cout<<b[i]<<" ";
    }
    cout<<endl;
} 

void printC(){
    cout<<"c数组"<<endl;
    cout<<setw(7)<<"c[i]:"<<" "; 
    for(int i=1;i<=n;i++){
        cout<<c[i]<<" ";
    }
    cout<<endl;
} 

int main(){
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    cin>>n;
    memset(a,0,sizeof(a));
    memset(b,0,sizeof(b));
    memset(c,0,sizeof(c));
    //离散化 
    for(int i=1;i<=n;i++){
        cin>>a[i].v;
        a[i].id=i;
    }
    printA();
    sort(a+1,a+n+1);
    cout<<endl<<"-----------------排序后-----------------"<<endl<<endl;; 
    printA();
    int pre=-1;
    int prevalue=0;
    for(int i=1;i<=n;i++){
        //判断离散化的时候两个值是否相同
        //离散化很简单，就是排序后一个个输出就好
        //下标的话依次递增就好了 
        if(pre!=a[i].v){
            pre=a[i].v;
            a[i].v=++prevalue;
        }
        else a[i].v=prevalue;
    }
    cout<<endl<<"-----------------离散化后-----------------"<<endl<<endl; 
    printA();
    //这部分就是排序后给它逆回来 
    for(int i=1;i<=n;i++){
        cout<<"i: "<<i<<" a[i].id: "<<a[i].id<<" a[i].v:"<<a[i].v<<endl; 
        b[a[i].id]=a[i].v;
    }
    printB();
    long long s=0;
    //逆序求解 
    cout<<endl<<"-----------------逆序求解-----------------"<<endl<<endl; 
    printC(); 
    for(int i=n;i>=1;i--){
        cout<<"i: "<<i<<endl;
        Change(b[i]);
        s+=Query(b[i]-1);
        printC(); 
        cout<<"i: "<<i<<" b[i]: "<<b[i]<<" Query(b[i]-1):"<<Query(b[i]-1)<<endl; 
    } 
    cout<<endl<<"-----------------结果-----------------"<<endl<<endl;; 
    cout<<s<<endl;;
    return 0;
} 

运行过程：

a数组
id: 1 2 3 4 5
value: 2 3 1 5 4

-----------------排序后-----------------

a数组
id: 3 1 2 5 4
value: 1 2 3 4 5

-----------------离散化后-----------------

a数组
id: 3 1 2 5 4
value: 1 2 3 4 5
i: 1 a[i].id: 3 a[i].v:1
i: 2 a[i].id: 1 a[i].v:2
i: 3 a[i].id: 2 a[i].v:3
i: 4 a[i].id: 5 a[i].v:4
i: 5 a[i].id: 4 a[i].v:5
b数组
b[i]: 2 3 1 5 4

-----------------逆序求解-----------------

c数组
c[i]: 0 0 0 0 0
i: 5
c数组
c[i]: 0 0 0 1 0
i: 5 b[i]: 4 Query(b[i]-1):0
i: 4
c数组
c[i]: 0 0 0 1 1
i: 4 b[i]: 5 Query(b[i]-1):1
i: 3
c数组
c[i]: 1 1 0 2 1
i: 3 b[i]: 1 Query(b[i]-1):0
i: 2
c数组
c[i]: 1 1 1 3 1
i: 2 b[i]: 3 Query(b[i]-1):1
i: 1
c数组
c[i]: 1 2 1 4 1
i: 1 b[i]: 2 Query(b[i]-1):1

-----------------结果-----------------

3

这里的前缀和是比这个数小的个数，比如说倒数第二个数5，那么就是求的5后面比我小的数之和，也就是4的前缀和。 

树状数组在这里用的就是前缀和。

---

测试离散化：

输入数据：

5
4 6 2 10 8

运行过程：

a数组
id: 1 2 3 4 5
value: 4 6 2 10 8

-----------------排序后-----------------

a数组
id: 3 1 2 5 4
value: 2 4 6 8 10

-----------------离散化后-----------------

a数组
id: 3 1 2 5 4
value: 1 2 3 4 5
i: 1 a[i].id: 3 a[i].v:1
i: 2 a[i].id: 1 a[i].v:2
i: 3 a[i].id: 2 a[i].v:3
i: 4 a[i].id: 5 a[i].v:4
i: 5 a[i].id: 4 a[i].v:5
b数组
b[i]: 2 3 1 5 4

-----------------逆序求解-----------------

c数组
c[i]: 0 0 0 0 0
i: 5
c数组
c[i]: 0 0 0 1 0
i: 5 b[i]: 4 Query(b[i]-1):0
i: 4
c数组
c[i]: 0 0 0 1 1
i: 4 b[i]: 5 Query(b[i]-1):1
i: 3
c数组
c[i]: 1 1 0 2 1
i: 3 b[i]: 1 Query(b[i]-1):0
i: 2
c数组
c[i]: 1 1 1 3 1
i: 2 b[i]: 3 Query(b[i]-1):1
i: 1
c数组
c[i]: 1 2 1 4 1
i: 1 b[i]: 2 Query(b[i]-1):1

-----------------结果-----------------

3