poj 2299 Ultra-QuickSort（树状数组）

题目大意：

给一串数字，问冒泡排序需要进行多少次交换

其实稍微模拟一下就可以发现，这一题其实就是要求逆序对的个数

不过要解决一个问题就是：这些数组太大，难以用树状数组进行维护，可以用坐标离散化来做，因为每个数字都不相同，所以很好实现的

我的离散化实现：

sort(a+1, a+n+1);
for (i=1; i<=n; i++)
b[a[i].id] = i;

其它的按照求逆序对的方法来做就好了。

我的代码：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
using namespace std;

class node
{
public:
int val, id;
};
bool operator < (const node &a, const node &b)
{
return a.val < b.val;
}

const int MAXN = 6e5;
int n;
node a[MAXN];
int b[MAXN], h[MAXN];

int lowbit(int x)
{
return x & (-x);
}
int query(int x)
{
int ans = 0;
while (x > 0)
{
ans += h[x];
x -= lowbit(x);
}
return ans;
}
void updata(int x, int val)
{
while (x <= n)
{
h[x] += val;
x += lowbit(x);
}
}
int main()
{
long long ans;
int i;
while (scanf("%d",&n))
{
if (n == 0)
break;
for (i=1; i<=n; i++)
{
scanf("%d",&a[i].val);
a[i].id = i;
h[i] = 0;
}
sort(a+1, a+n+1);
for (i=1; i<=n; i++)
b[a[i].id] = i;
ans = 0;
for (i=n; i>=1; i--)
{
ans += 1ll * query(b[i]-1);
updata(b[i], 1);
}
printf("%lld\n", ans);
}
return 0;
}