POJ 2299 Ultra-QuickSort（逆序数 树状数组+离散化）

- POJ 2299 -

Ultra-QuickSort

Time Limit: 7000MS | Memory Limit: 65536K

题意：

給定一个长度为 n 的数组，用冒泡排序使得它有序，求交换操作的次数；即求该数组的逆序数之和或者逆序对（即满足i<j，a[i]>a[j]的数对）个数。（有多组输入，当 n 为 0 时输入结束）
> 逆序数

数据范围：

n < 500000，0 ≤ a[i] ≤ 999999999

解题思路：

树状数组+离散化 or 归并排序

树状数组可以用于解决有关逆序对的问题，但是当数值范围较大时，需要先进行离散化，再用树状数组进行计算；另外，归并排序也可以快速求解逆序对问题，并且，由于离散化本身就要通过排序来实现，所以在这种情况下不如直接使用归并排序来计算。

用归并排序的话，当需要归并的两个部分都是分别有序的时候，只需要统计：对于后者的每个数来说，前者有多少个数比它大（即前者中第一个大于它的数 后面的数的个数+1），最后得到的总和即为答案。

代码：

① 树状数组+离散化：
Memory: 5384K | Time: 516MS

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <set>
using namespace std;
#define INF 0x3f3f3f
#define zero 1e-7
//逆序对
typedef long long ll;
const int N=5e5+5;

int n, sum[N];

struct node {
    int v, id;
}a[N];

bool cmp(node x, node y) {
    return x.v<y.v;
}

int lowbit(int x) {
    return x&(-x);
}

void add(int x, int c) {
    while(x<=n) {
        sum[x]+=c;
        x+=lowbit(x);
    }
    return ;
}

int query(int x) {
    int ans=0;
    while(x) {
        ans+=sum[x];
        x-=lowbit(x);
    }
    return ans;
}

int main() {
    while(scanf("%d", &n), n) {
        for(int i=1; i<=n; i++) {
            scanf("%d", &a[i].v);
            a[i].id=i;
        }
        sort(a+1, a+n+1, cmp);
        //从最小的开始一个个除去，同时计算该数前面有多少个比它大的
        //所以要初始化第i个数的逆序数为它前面的数的个数，在树状数组里即为sun[i]=lowbit[i]
        for(int i=1; i<=n; i++)
            sum[i]=lowbit(i);
        ll ans=0;
        for(int i=1; i<=n; i++) {
            add(a[i].id, -1);
            ans+=(ll)(query(a[i].id-1));
        }
        printf("%I64d\n", ans);
    }
    return 0;
}

② 归并排序：
Memory: 3616K | Time: 391MS

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <set>
using namespace std;
#define INF 0x3f3f3f
#define zero 1e-7

typedef long long ll;
const int N=5e5+5;

int a[N], b[N], n;
ll ans;

void mergeSort(int l, int r) {
    if(l>=r) return ;
    int mid=(l+r)>>1;
    mergeSort(l, mid);
    mergeSort(mid+1, r);
    int p1=l, p2=mid+1, t=l;
    while(p2<=r || p1<=mid) {
        if(p1<=mid && a[p1]<=a[p2] || p2>r) b[t++]=a[p1++];
        else {
            if(p1<=mid) ans+=(ll)(mid-p1+1);
            b[t++]=a[p2++];
        }
    }
    for(int i=l; i<=r; i++)
        a[i]=b[i];
    return ;
}

int main() {
    while(scanf("%d", &n), n) {
        ans=0;
        for(int i=1; i<=n; i++)
            scanf("%d", &a[i]);
        mergeSort(1, n);
        printf("%I64d\n", ans);
    }
    return 0;
}