poj 2299 Ultra-QuickSort（树状数组求逆序数）

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

题意：给出n个数，求将这n个数从小到大排序，求使用快排的需要交换的次数。

分析：由快排的性质很容易发现，只需要求每个数的逆序数累加起来就行了。逆序数可以用树状数组求。

n<500000，0<=a[i]<=999,999,999，很明显数组不可能开这么大，所以需要离散化。

可以用一个结构体

struct node{
    int val,pos;
}a[N];

pos表示每个数的下标，val表示该数的值

按val从小到大排序，然后b[a[i].pos]]=i，就实现了离散化，保证了原来序列的大小关系不变。

之后就是简单的树状数组求逆序数了。

AC代码如下：

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 const int N=;
 #define LL __int64
 int c[N],b[N],n;
 struct node{
     int val,pos;
     bool operator <(const node &a)const{
         return val<a.val;
     }
 }a[N];
 int lowbit(int x)
 {
     return x&(-x);
 }
 void update(int x,int num)
 {
     while(x<=N)
     {
         c[x]+=num;
         x+=lowbit(x);
     }
 }
 LL sum(int x)
 {
     LL s=;
     while(x>)
     {
         s+=c[x];
         x-=lowbit(x);
     }
     return s;
 }
 int main()
 {
     int i;
     while(scanf("%d",&n)&&n)
     {
         for(i=;i<=n;i++)
         {
             scanf("%d",&a[i].val);
             a[i].pos=i;
         }
         sort(a+,a+n+);
         for(i=;i<=n;i++)
             b[a[i].pos]=i;
         memset(c,,sizeof(c));
         LL ans=;
         for(i=;i<=n;i++)
         {
             update(b[i],);
             ans+=i-sum(b[i]);
         }
         printf("%I64d\n",ans);
     }
     return ;
 }