分治法 or BIT 求逆序对

方法1：
求逆序对可以利用归并排序来求，其实就是分治。
归并排序在排序过程很中对于一样的数比较是不会改变次序的，因而可以用来求逆序对。
代码如下：

 1 #include<stdio.h>
 2 
 3 void Merge(int ,int ,int );
 4 void mergeSort(int ,int );
 5 
 6 int ch[20000],temp[20000];
 7 int count = 0;
 8 
 9 void mergeSort(int lo,int hi) {//递归函数里不断二分排序，归并。
10     if(lo < hi) {
11 
12         int mid =( lo + hi ) / 2;
13 
14         mergeSort(lo,mid);
15         mergeSort(mid + 1,hi);
16 
17         Merge(lo,mid,hi);
18     }
19 }
20 
21 void Merge(int lo,int mid,int hi) {//进行归并
22     int i = lo;
23     int j = mid + 1;
24     int x = lo;
25 
26     while(i <= mid&&j <= hi) {
27         if ( ch[i] > ch[j]) {
28             count+=  mid - i + 1;
29             temp[x++] = ch[j++];
30         } else {
31             temp[x++] = ch[i++];
32         }
33     }
34 
35     while(i <= mid) temp[x++] = ch[i++];
36     while(j <= hi)    temp[x++] = ch[j++];
37 
38     for(int k = lo; k <= hi ; k++)
39         ch[k]  = temp[k];
40 
41 }
42 int main() {
43     int N;
44     scanf("%d",&N);
45 
46     for(int i=0; i < N; i++) {
47         scanf("%d",&ch[i]);
48     }
49 
50     mergeSort(0,N-1);
51 
52     printf("%d\n",count);
53     return 0;
54 }

方法二：
利用树状数组（BIT）来求；
首先对于将数字离散化，这个我们是需要用到排序的，我们需要使用数字的大小来记录这个数本来在第几位，以及这个数在求逆序对之前应该在第几位。（有时数据太大不好直接开数组）

对于离散化后的数据（按照顺序保存），我们要对其进行操作，加装一个新的数组（按位置保存的数组），然后算每个数据在整个数据中应该排第几位

利用BIT计算。

#include <iostream>
#include <cstring>
#include <algorithm>
#define lowbit(x) x&-x
using namespace std;
int n;
long long ans;
int c[100010];
struct edge{
    int v,pos;
}in[100010];
bool cmp(edge a,edge b){
    return a.v < b.v;
}
long long aa[100010];
int query(int x){
    long long ret = 0;
    while(x > 0){
        ret += c[x];
        x -= lowbit(x);
    }
    return ret;
}
void add(int x,int d){
    while(x <= n){
        c[x] += d;
        x += lowbit(x);
    }
}
int main(){
    cin >> n;
    ans = 0;
    memset(aa,0,sizeof(aa));
    memset(c,0,sizeof(c));
    for(int i = 1;i <= n;++i){
        cin >> in[i].v;
        in[i].pos = i;
    }
    sort(in+1,in+n+1,cmp);
    int reflect = 0;
    for(int i = 1;i <= n;++i){
        if(in[i].v != in[i-1].v)reflect++;
        aa[in[i].pos] = reflect;
    }
    for(int i = 1;i <= n;++i){
        add(aa[i],1);
        ans += i - query(aa[i]);
    }
    cout << ans << endl;
    return 0;
}