POJ2299 Ultra-QuickSort 树状数组+离散化

题目链接：http://poj.org/problem?id=2299

题目大意：

在某些问题上,你必须分析特定的排序算法。 该算法处理一系列n个不同的整数通过交换两个相邻序列元素,直到按升序排序序列。 对输入序列 

9 1 0 5 4,

超快速排序生成的输出 

0 1 4 5 9。

你的任务是确定超快速排序需要执行多少互换操作对于给定输入序列。

输入：

测试数据有多组，每组测试数组第一行输入整数n（n < 500,000 ）表示序列中元素的个数，第二行为n个正整数表示序列中元素大小（0 ≤ a[i] ≤ 999,999,999），输入以0做结尾，0不作处理。

输出：

对于每个测试用例，输出一行，包含一个整数，给定序列的操作最小数目。

分析：有了关于逆序数的知识储备后再看本题==>数组元素大小是10^9级的，直接用树状数组做显然是不行的，考虑到每次最多有500000个元素，我们离散化用区间[1,500000]来对应数组中的每一个元素，然后找出离散化数组的逆序数即可。

实现代码如下：

//
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int M=500005;
struct node
{
    int num1,id,x;
    bool operator <(const node &m) const
    {
        return num1<m.num1;
    }
}p[M];
int a[M],n,num[M];
int lowbit(int i)
{
    return i&(-i);
}
void update(int i)
{
    while(i<=M)
    {
        a[i]++;
        i+=lowbit(i);
    }
}
int query(int n)
{
    int sum=0;
    while(n>0)
    {
        sum+=a[n];
        n-=lowbit(n);
    }
    return sum;
}
int main()
{
    while(scanf("%d",&n)&&n)
    {
        memset(a,0,sizeof(a));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&p[i].num1);
            num[i]=p[i].num1;
            p[i].id=i;
        }
        sort(p+1,p+1+n);
        for(int i=1;i<=n;i++)
          p[i].x=i;
        for(int i=1;i<=n;i++)
          num[ p[i].id ]=p[i].x;
        long long ans=0;
        for(int i=1;i<=n;i++)
        {

            update(num[i]);
            ans+=i-query(num[i]);
        }
        printf("%I64d\n",ans);
    }
    return 0;
}