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