求逆序数（the number of inversions）（数学）

1.用树状数组求逆序数

缺点：只能对整数求逆序数

#include "TreeArray.h"
/*
算法：
由树状数组求逆序对。加入元素i即把以元素i为下标的a[i]值+1，从队尾到队首入队，
每次入队时逆序对数 += getsum(i - 1),即下标比它大的但是值比它小的元素个数。
因为树状数组不能处理下标为0的元素，每个元素进入时+1，相应的其他程序也要相应调整。
求出原始的序列的逆序对个数后每次把最前面的元素移到队尾，逆序对数即为
原逆序对数+比i大的元素个数-比i小的元素个数，因为是0..n,容易直接算出
*/
int NiXuShu(int Array[], int n)
{
    TreeArray ta(1);
    ta.clear();
    int i, sum = 0;
    for (i = n-1; i >= 0; i --)
    {
        ta.modify(Array[i]+1, 1);
        sum = sum + ta.sum(Array[i]);
    }
    return sum;
}

这种方法理解的还不是很透彻，还是要再理解一下。 

2.用归并排序求逆序数

缺点：会改变数组中的值

# include <iostream>
# define N 500010
using namespace std;

long long cnt;
int a[N], t[N];
void merge(int s1, int e1, int s2, int e2)
{
    int p1 = s1, p2 = s2, p=0;
    while(p1 <= e1 && p2 <= e2)
    {
        if(a[p1] <= a[p2])
        {
            t[p++] = a[p1++];
        }
        else
        {
            t[p++] = a[p2++];
            cnt += e1-p1+1;
        }
    }
    while(p1<=e1)
    {
        t[p++] = a[p1++];
    }
    while(p2 <= e2)
    {
        t[p++] = a[p2++];
    }
    for(int i = s1; i <= e2; i++)
    {
        a[i] = t[i-s1];
    }
}
void mergesort(int s, int e)
{
    if(s < e)
    {
        int m = (s+e)/2;
        mergesort(s, m);
        mergesort(m+1, e);
        merge(s, m, m+1, e);
    }
}
int main(void)
{
    int n;
    while(cin >> n, n)
    {
        cnt = 0;
        for(int i = 0; i < n; i++)
            cin >> a[i];
        mergesort(0, n-1);
        cout << cnt << endl << endl;
    }

    return 0;
}

用cin的话跑时会很多，还是scanf好。