poj--2299 Ultra-QuickSort（树状数组求逆序数）

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

 题意：给出一个数组，只能够相邻的两个数进行交换求最少有多少次操作后能变成由小到大排列。

思路：这个题是求 逆序数 可用树状数组求逆序数或者用归并排序求逆序数。

树状数组AC代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
int c[500005],n;
struct note
{
    int x,y;
} a[500005];
int cmp(const struct note &a,const struct note &b)
{
    return a.x<b.x;
}
int lowbit(int m)
{
    return m&(-m);
}
int updata(int p,int q)
{
    while(p<=n)
    {
        c[p]+=q;
        p+=lowbit(p);
    }
    return 0;
}
int getsum(int m)
{
    int sum;
    sum=0;
    while(m)
    {
        sum+=c[m];
        m-=lowbit(m);
    }
    return sum;
}
int main()
{
    long long ans;
    while(~scanf("%d",&n))
    {
        if(n==0)
            break;
        memset(c,0,sizeof(c));
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&a[i].x);
            a[i].y=i;
        }
        sort(a+1,a+n+1,cmp);
        ans=0;
        for(int i=1; i<=n; i++)
        {
            updata(a[i].y,1);
            ans+=i-getsum(a[i].y);
        }
        printf("%lld
",ans);
    }
    return 0;
}

 归并排序AC代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
int a[500005],c[500005];
long long cnt;
void mergesort(int l,int r)
{
    int mid,i,j,tmp;
    if(r>l+1)
    {
        mid=(l+r)/2;
        mergesort(l,mid);
        mergesort(mid,r);
        tmp=l;
        for(i=l,j=mid; i<mid&&j<r;)
        {
            if(a[i]>a[j])
            {
                c[tmp++]=a[j++];
                cnt+=mid-i;
            }
            else
                c[tmp++]=a[i++];
        }
        if(j<r)
            for(; j<r; ++j)
                c[tmp++]=a[j];
        else
            for(; i<mid; ++i)
                c[tmp++]=a[i];
        for(i=l; i<r; ++i)
            a[i]=c[i];
    }
}
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        if(n==0)
            break;
        memset(c,0,sizeof(c));
        for(int i=0; i<n; i++)
            scanf("%d",&a[i]);
        cnt=0;
        mergesort(0,n);
        printf("%lld
",cnt);
    }
    return 0;
}

提示：由于数据较大，答案应该用 long long储存。