POJ Ultra-QuickSort (树状数组+离散化)

题目大意：给定 n 个互不相同的数， 求将这 n 个数按升序排列所需最少交换次数 ， 每次只能交换相邻的两个数。 也就是说求这 n 个数的逆序数之和 ， 即对于每个数求在它之前有多少个比它大的数。

很容易想到用树状数组来求逆序数 ， 对于每个数a[i] ， 只需求出在此之前a[i] - 1 的前缀和即可。因此需要的空间大小最大是max{a[i]}， 而这个题目中a[i]最大为10亿 ， 明显不能开这么大的空间。 因此需要用到离散化的操作。

离散化过程：
1. 给定一个结构体
struct Node {
int v , p;
bool operator < (Node const &rhs) const {
return v > rhs.v;
}
}nd[maxn];
其中 v 表示第 i 个元素的值 ， p 表示第 i 个元素在原数组的位置。
然后按 v 的大小排序。
2. 另建立一个数组reflect[maxn]， 将
reflect[nd[i].p] = i
这样， 得到的reflect数组 ， 元素之间的关系和原数组完全一样 ， 但最大是50W，大大降低了空间复杂度。

离散化之后， 即可使用树状数组求解。

代码

/* 树状数组 + 离散化
 */
#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;
const int maxn = 500010;
struct Node {
    int v , p;
    bool operator < (Node const &rhs) const {
        return v > rhs.v;
    }
}nd[maxn];
int reflect[maxn];
int c[maxn] , n;

int lowbit(int x) {return x & (-x);}
void add(int x , int v)
{
    while(x <= n) {
        c[x] += v;
        x += lowbit(x);
    }
}
int sum(int x)
{
    int rel = 0;
    while(x > 0) {
        rel += c[x];
        x -= lowbit(x);
    }
    return rel;
}
int main()
{
    ios::sync_with_stdio(false);
    while(cin >> n && n)
    {
        for(int i = 1; i <= n; i++) {cin >> nd[i].v; nd[i].p = i;}
        sort(nd + 1 , nd + n + 1);
        for(int i = 1; i <= n; i++) reflect[nd[i].p] = i;
        memset(c , 0 , sizeof(c));
        long long ans = 0;
        for(int i = 1; i <= n; i++) {
            ans += sum(reflect[i]-1);
            add(reflect[i] , 1);
        }
        cout << ans << endl;
    }
}