poj2299

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring>
#define MAX 500005


using namespace std;


struct node
{
    long long val;
    int pos;
}a[MAX];


int ans[MAX];
int c[MAX];


bool cmp1(node a,node b)
{
    return a.val<b.val;
}


bool cmp2(node a,node b)
{
    return a.pos<b.pos;
}


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


void add(int po,int val)
{
    while (po<=MAX)
    {
        c[po]+=val;
        po+=lowbit(po);
    }
}


int getsum(int po)
{
    int sum=0;
    while (po>0)
    {
        sum+=c[po];
        po-=lowbit(po);
    }
    return sum;
}


int main()
{
    int n;
    freopen("in.txt","r",stdin);
    while (cin>>n)
    {
        if (n==0) break;
        int i;
        memset(c,0,sizeof(c));
        memset(ans,0,sizeof(ans));
        for (i=1;i<=n;i++)
         {
            scanf("%lld",&a[i].val);
            a[i].pos=i;
         }
        sort(a+1,a+n+1,cmp1);
        for (i=1;i<=n;i++) a[i].val=i;  //离散化
        sort(a+1,a+n+1,cmp2);
        for (i=1;i<=n;i++)
        {
            add(a[i].val,1);             //c数组是不用另外更新的
            ans[i]=i-getsum(a[i].val);
         }
         long long  fians=0;
         for (i=1;i<=n;i++) fians+=ans[i];
         cout<<fians<<endl;


    }
    return 0;
}
/*给定n个数，要求这些数构成的逆序对的个数。除了用归并排序来求逆序对个数，还可以使用树状数组来求解。
树状数组求解的思路：开一个能大小为这些数的最大值的树状数组，并全部置0。从头到尾读入这些数，每读入一个数就更新树状数组，
查看它前面比它小的已出现过的有多少个数sum，然后用当前位置减去该sum，就可以得到当前数导致的逆序对数了。把所有的加起来就是总的逆序对数。
题目中的数都是独一无二的，这些数最大值不超过999999999，但n最大只是500000。如果采用上面的思想，必然会导致空间的巨大浪费，而且由于内存的限制，我们也不可能开辟这么大的数组。因此可以采用一种称为“离散化”的方式，把原始的数映射为1-n一共n个数，这样就只需要500000个int类型的空间。
离散化的方式：
struct node
{
int val;
int pos;
};
node a[MAX];
val存放原数组的元素，pos存放原始位置，
把这些结构体按照val的大小排序。
令a[i].val=i;
再按pos排序，恢复原来顺序*/