POJ 2299 Ultra-QuickSort（求逆序数，归并排序或者离散化+树状数组）

Ultra-QuickSort

Time Limit: 7000MS		Memory Limit: 65536K
Total Submissions: 27665		Accepted: 9915

Description

In this problem, you have to analyze a particular sorting algorithm. The algorithm processes a sequence of n distinct integers by swapping two adjacent sequence elements until the sequence is sorted in ascending order. For the input sequence
9 1 0 5 4 ,
Ultra-QuickSort produces the output
0 1 4 5 9 .
Your task is to determine how many swap operations Ultra-QuickSort needs to perform in order to sort a given input sequence.

Input

The input contains several test cases. Every test case begins with a line that contains a single integer n < 500,000 -- the length of the input sequence. Each of the the following n lines contains a single integer 0 ≤ a[i] ≤ 999,999,999, the i-th input sequence element. Input is terminated by a sequence of length n = 0. This sequence must not be processed.

Output

For every input sequence, your program prints a single line containing an integer number op, the minimum number of swap operations necessary to sort the given input sequence.

Sample Input

5

9

1

0

5

4

3

1

2

3

0

Sample Output

6

0

Source

Waterloo local 2005.02.05

 

 

本题就是求逆序数

 

一种方法是用归并排序求逆序数

 

/*

POJ 2299 Ultra-QuickSort

求逆序数

用归并排序求逆序数

*/

#include <stdio.h>

#include<string.h>

#include<iostream>

using namespace std;

const int MAXN=500010;

long long ans;//存放逆序数，比较大，必须用long long

int a[MAXN],b[MAXN],c[MAXN];



//将已经排好序的left~mid,mid+1~right进行归并

void merge(int *a,int left,int mid,int right)

{

    int i,j;

    i=0;

    for(j=left;j<=mid;j++)

       b[i++]=a[j];

    int len1=mid-left+1;

    i=0;

    for(j=mid+1;j<=right;j++)

       c[i++]=a[j];

    int len2=right-mid;

    i=0;

    j=0;

    int k=left;

    while(i<len1&&j<len2&&k<=right)

    {

        if(b[i]<=c[j])

        {

            a[k++]=b[i++];

        }

        else

        {

            a[k++]=c[j++];

            ans+=(len1-i);//逆序数就是累加后面比自己小的数的个数

            //此时b[i]>c[j],那么c[j]会给b[i]后面的len1-i个数造成逆序数

        }

    }

    while(i<len1) a[k++]=b[i++];

    while(j<len2) a[k++]=c[j++];

}

void merge_sort(int *a,int left,int right)//对a[left~right-1]进行归并排序

{

    if(left<right)

    {

        int mid=(left+right)/2;

        merge_sort(a,left,mid);

        merge_sort(a,mid+1,right);

        merge(a,left,mid,right);

    }

}

int main()

{

    //freopen("in.txt","r",stdin);

    //freopen("out.txt","w",stdout);

    int n;

    while(scanf("%d",&n),n)

    {

        for(int i=0;i<n;i++)

          scanf("%d",&a[i]);

        ans=0;

        merge_sort(a,0,n-1);

        printf("%I64d\n",ans);

    }

    return 0;

}

 

 

另外一种求逆序数的方法就是用树状数组。

本题数据比较大，需要先离散化，再用树状数组。

代码如下：

/*

POJ 2299 Ultra-QuickSort

求逆序数

离散化+树状数组

首先从小到大进行编号，从而实现离散化

然后利用树状数组来统计每个数前面比自己大的数的个数

*/



#include<stdio.h>

#include<string.h>

#include<algorithm>

#include<iostream>

using namespace std;

const int MAXN=500010;

int c[MAXN];

int b[MAXN];

int n;

struct Node

{

    int index;//序号

    int v;

}node[MAXN];

bool cmp(Node a,Node b)

{

    return a.v<b.v;

}

int lowbit(int x)

{

    return x&(-x);

}

void add(int i,int val)

{

    while(i<=n)

    {

        c[i]+=val;

        i+=lowbit(i);

    }

}

int sum(int i)

{

    int s=0;

    while(i>0)

    {

        s+=c[i];

        i-=lowbit(i);

    }

    return s;

}

int main()

{

   // freopen("in.txt","r",stdin);

    //freopen("out.txt","w",stdout);

    while(scanf("%d",&n),n)

    {

        for(int i=1;i<=n;i++)

        {

            scanf("%d",&node[i].v);

            node[i].index=i;

        }

        memset(b,0,sizeof(b));

        memset(c,0,sizeof(c));

        //离散化

        sort(node+1,node+n+1,cmp);

        //将最小的编号为1

        b[node[1].index]=1;

        for(int i=2;i<=n;i++)

        {

            if(node[i].v!=node[i-1].v) b[node[i].index]=i;

            else b[node[i].index]=b[node[i-1].index];

        }

        long long  ans=0;

        //这里用的很好

        //一开始c数组都是0，然后逐渐在b[i]处加上1；

        for(int i=1;i<=n;i++)

        {

            add(b[i],1);

            ans+=sum(n)-sum(b[i]);

        }

        printf("%I64d\n",ans);

    }

    return 0;

}