逆序数 POJ 2299 Ultra-QuickSort

题目传送门

/*
    题意：就是要求冒泡排序的交换次数。
    逆序数：在一个排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序。
    一个排列中逆序的总数就称为这个排列的逆序数。逆序数为偶数的排列称为偶排列；逆序数为奇数的排列称为奇排列。
    如2431中，21，43，41，31是逆序，逆序数是4，为偶排列。也是就说，对于n个不同的元素，
    先规定各元素之间有一个标准次序（例如n个 不同的自然数，可规定从小到大为标准次序），于是在这n个元素的任一排列中，
    当某两个元素的先后次序与标准次序不同时，就说有1个逆序。一个排列中所有逆序总数叫做这个排列的逆序数。

    接下来有多种做法求解逆序数：1. 暴力；2. 归并排序；3. 线段树-单点更新；4. 树状数组
*/

/*
    暴力 超时 O(n^2)
*/
#include <stdio.h>

const int MAX_N = 500000;
int a[MAX_N+10];
long long cnt = 0;

int main(void)        //POJ 2299 Ultra-QuickSort
{
    //freopen ("inD.txt", "r", stdin);
    int n;
    
    while (scanf ("%d", &n) != EOF && n)
    {
        for (int i=1; i<=n; ++i)
        {
            scanf ("%d", &a[i]);
        }

        for (int i=1; i<=n; ++i)
        {
            for (int j=i+1; j<=n; ++j)
            {
                if (a[i] > a[j])
                    cnt++;
            }
        }
        printf ("%lld
", cnt);
        cnt = 0;
    }
    
    return 0;
}

/* 
    归并排序是将数列a[p, r]分成两半a[p, q]和a[q+1,r]分别进行归并排序，
    然后再将这两半合并起来。在合并的过程中（设p<=i<=q，q+1<=j<=r），
    当L[i]<=R[j]时，并不产生逆序数；
    当L[i]>R[j]时，在前半部分中比L[i]大的数都比R[j]大，
    将R[j]放在L[i]前面的话，逆序数要加上q+1-i。
    因此，可以在归并排序中的合并过程中计算逆序数。 
 
    这道题充分印证了，即使merge本身可能用的不多，但分冶的思想却是无所不在:)
*/
#include <stdio.h>

const int MAX_N = 500000;
const int INF = 0xffffff;
int a[MAX_N+10];
long long cnt = 0;
 
void Merge(int *a, int p, int q, int r)
{
    int n1 = q - p + 1;
    int n2 = r - q;
    int L[MAX_N/2+1], R[MAX_N/2+1];
    int i, j;
    for (i=1; i<=n1; ++i)    L[i] = a[p+i-1];
    for (j=1; j<=n2; ++j)    R[j] = a[q+j];
    L[n1+1] = INF;    R[n2+1] = INF;

    i = 1;    j = 1;
    for (int k=p; k<=r; ++k)
    {
        if (L[i] <= R[j])
        {
            a[k] = L[i++];
        }
        else
        {
            a[k] = R[j++];
            cnt += n1 - i + 1;         //此步骤是在归并排序法中加的一句，用来计数求逆序数的数目
        }
    }
}

void MergeSort(int *a, int p, int r)
{
    int q;
    if (p < r)
    {
        q = (p + r) / 2;
        MergeSort (a, p, q);
        MergeSort (a, q+1, r);
        Merge (a, p, q, r);
    }
}

int main(void)        //POJ 2299 Ultra-QuickSort
{
    //freopen ("inD.txt", "r", stdin);
    int n;
    
    while (scanf ("%d", &n) != EOF && n)
    {
        for (int i=1; i<=n; ++i)
        {
            scanf ("%d", &a[i]);
        }
        MergeSort (a, 1, n);
        printf ("%lld
", cnt);
        cnt = 0;
    }
    
    return 0;
}

/*
    线段树-单点更新
*/
#include <cstdio>
#include <algorithm>
#define lson l, m, rt << 1
#define rson m+1, r, rt << 1 | 1
using namespace std;

const int MAX_N = 500000;
const int INF = 0x3f3f3f3f;
int a[MAX_N];
int b[MAX_N];
int sum[MAX_N << 2];

void pushup(int rt)
{
    sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}

void build(int l, int r, int rt)
{
    sum[rt] = 0;
    if (l == r) return ;
    int m = (l + r) >> 1;
    build (lson);
    build (rson);

    pushup (rt);
}

void update(int p, int l, int r, int rt)
{
    if (l == r)
    {
        sum[rt]++;      //记录次数
        return ;
    }
    int m = (l + r) >> 1;
    if (p <= m)
    {
        update (p, lson);
    }
    else
        update(p, rson);
    pushup (rt);
}

int query(int ql, int qr, int l, int r, int rt)
{
    if (ql <= l && r <= qr)
    {
        return sum[rt];
    }
    int m = (l + r) >> 1;
    int ans = 0;
    if (ql <= m)    ans += query (ql, qr, lson);
    if (qr > m)     ans += query (ql, qr, rson);

    return ans;
}

int BinarySearch(int key, int l, int r)
{
    while (r >= l)
    {
        int mid = (l + r) >> 1;
        if (key == b[mid])    return mid;
        if (key < b[mid])    r = mid - 1;
        else    l = mid + 1;
    }
}

int main(void)
{
    //freopen ("inD.txt", "r", stdin);
    int n;
    while (~scanf ("%d", &n) && n)
    {
        build (0, n-1, 1);
        
        for (int i=1; i<=n; ++i)   
        {
            scanf ("%d", &a[i]);
            b[i] = a[i];
        }
        sort (b+1, b+n+1);
        long long ans = 0;
        for (int i=1; i<=n; ++i)
        {
            int x = BinarySearch (a[i], 1, n);
            ans += query (x, n, 1, n, 1);
            update (x, 1, n, 1);
        }
        printf ("%lld
", ans);
    }

    return 0;
}