poj2299离散化加树状数组求逆序数

poj2299题目链接
题意：给出n个数，求将这n个数从小到大排序，求使用快排的需要交换的次数。
分析：由快排的性质很容易发现，只需要求每个数的逆序数累加起来就行了。逆序数可以用树状数组求。

 

n<500000，0<=a[i]<=999,999,999，

 

下面是树状数组的一张图

如果n=8有8个数，树状数组中的A[1~8]

很明显数组不可能开这么大，所以需要离散化。

什么是离散化呢？

如有5个数：1 100000 888 22222222 19

则可以离散成 1 4 3 5 2，即它们的相对大小没变

我们可以定义一个结构体。

struct Dis
{
    int order;//原本输入的顺序
    int value;//原本的值
}a[N];

现在我选择下标从1开始，则有

a[1].value=1; a[1].order=1;

a[2].value=100000 ; a[2].order=2;

a[3].value=888 ; a[3].order=3;

a[4].value=22222222 ; a[4].order=4;

a[5].value=19; a[5].order=5;

按value从小大大排序

则有

a[1].value=1; a[1].order=1;

a[2].value=19; a[2].order=5;

a[3].value=888; a[3].order=3;

a[4].value=100000; a[3].order=2;

a[5].value=22222222; a[3].order=4;

定义dis[N]为离散化后的的数组

for(int i=1;i<=5;i++)

dis[a[i].order]=i;

则有

dis[1]=1;

dis[5]=2;

dis[3]=3;

dis[2]=4;

dis[4]=5;

所以最后的离散数组为：1 4 3 5 2

假设现在输入的是

5

1 4 3 5 2

1的逆序数为0

4的逆序数为0

3的逆序数为1（4比3大）

5的逆序数为0

2的逆序数为3（4,3,5比2大）

树状数组不太清楚的同学可以看看树状数组入门

则对应的树状数组的图为

A[i]=1则表示输入有1个i,A[i]=j则表示输入有j个i，按输入顺序

getsum(dis[i])得到的是前面比dis[i]小的数的个数+1，即<=dis[i]的个数，因为n个数由A[1~n]=1表示，后面的下标一定前面的下标大==

所以i-getsum(dis[i])就得到了dis[i]前面比dis[i]大的数的个数

1-1=0；

2-2=0；

3-2=1；

4-4=0；

5-2=3；

update(dis[i],1);

每更新一次,进行

ans+=i-getsum(dis[i])

最后ans即为解

AC代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=5e5+100;
int dis[N];//离散数组
int c[N];//树状数组
int n;
struct Dis
{
    int order;
    int value;
    bool operator < (const Dis &b)const{
        return value < b.value;
    }
}a[N];
int cmp(Dis A,Dis B)
{
    return A.value<B.value;
}
int lowbit(int x)
{
    return x&(-x);
}
void update(int x,int v)
{
    for(int i=x;i<=n;i+=lowbit(i)){
        c[i]+=v;
    }
}
int getsum(int x)
{
    int sum=0;
    for(int i=x;i>0;i-=lowbit(i)){
        sum+=c[i];
    }
    return sum;
}
int main()
{
    int i,j;
    while(cin>>n)
    {
        if(n==0)break;
        for(i=1;i<=n;i++){
            cin>>a[i].value;
            a[i].order=i;
        }
        memset(c,0,sizeof(c));
        sort(a+1,a+n+1);
        //离散化
        for(i=1;i<=n;i++){
            dis[a[i].order]=i;
        }
        __int64 ans=0;
        for(i=1;i<=n;i++){
            update(dis[i],1);
            ans+=i-getsum(dis[i]);
        }
        cout<<ans<<endl;
    }
}