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;
}