练习题 POJ2299的两种解法 树状数组/归并排序

Poj 2299 统计如果要对一串数据排序，冒泡排序需要交换多少次

即求逆序数，可以用树状数组或者归并排序求取。

//Poj 2299 树状数组解法
#include <stdio.h>
const int N = 500005;
struct Node{
    int val;
    int pos;
} pool[N];
int c[N], reflect[N], n;
 
int lowbit(int x){
    return x & (-x);
}
void update(int x){
    while (x <= n){
        c[x] += 1;
        x += lowbit(x);
    }
}
int getsum(int x){
    int sum = 0;
    while (x > 0){
        sum += c[x];
        x -= lowbit(x);
    }
    return sum;
}
int main(){
    while (scanf("%d", &n) != EOF && n){
        for (int i = 1; i <= n; ++i){
            scanf("%d", &pool[i].val);
            pool[i].pos = i;
        }
        qsort(1, n);   //排序
        for (int i = 1; i <= n; ++i) reflect[pool[i].pos] = i;   //离散化
        for (int i = 1; i <= n; ++i) c[i] = 0;   //初始化树状数组
        long long ans = 0;
        for (int i = 1; i <= n; ++i){
            update(reflect[i]);
            ans += i - getsum(reflect[i]);
        }
        printf("%lld\n", ans);
    }
    return 0;
}
void qsort(int s, int t){
    int l = s, r = t;
    Node tmp = pool[s];
    pool[s] = pool[l];
    while (true){
        while ((r > l) && (pool[r].val >= tmp.val))--r;
        if (r <= l)break;                  //再也找不到比tmp小的数
        pool[l] = pool[r];
        while ((l < r) && (pool[l].val <= tmp.val))++l;
        if (l >= r)break;
        pool[r] = pool[l];
    }
    pool[l] = tmp;
    if (s < --l)qsort(s, l);
    if (t > ++r)qsort(r, t);
}

 

/*POJ 2299 归并排序解法

求逆序对的数目可以使用归并排序，其实逆序对的数目是归并排序的一个附属产品，只是在归并排序的过程中顺便算出来的。

（2路）归并排序的思想：先把每个数看成一段，然后两两合并成一个较大的有序数组，再把较大的两两合并，直到最后成为一个有序数组。例如：

初始数组为：4 2 1 3

先把每个数看成一段，即：4 ｜ 2 ｜ 1 ｜ 3

接着两两合并成有序数组，即：2 4 ｜ 1 3

最后合并成总的有序数组，即：1 2 3 4

*/

#include <stdio.h>
long long num[500005];
long long temp[500005];
int n;
long long ans;
 
void merge(int low, int mid, int high){
    int i = low, j = mid + 1, k = low;
    while (i <= mid && j <= high){
        if (num[i] <= num[j]){
            temp[k++] = num[i++];
        }
        else{
            ans += j - k; //统计逆序,需要交换的次数
            temp[k++] = num[j++];
        }
    }
    while (i <= mid) temp[k++] = num[i++];
    while (j <= high) temp[k++] = num[j++];
    for (i = low; i <= high; ++i){
        num[i] = temp[i];
    }
}
void mergeSort(int a, int b){
    if (a < b){
        int mid = (a + b) / 2;
        mergeSort(a, mid);
        mergeSort(mid + 1, b);
        merge(a, mid, b);
    }
}
 
int main(){
    while (scanf("%d", &n) != EOF && n > 0){
        ans = 0;
        for (int i = 0; i < n; ++i)
            scanf("%lld", num + i);
        mergeSort(0, n - 1);
        printf("%lld\n", ans);
    }
    return 0;
}