逆序数 poj2299 Ultra-QuickSort

Ultra-QuickSort
Time Limit: 7000MS Memory Limit: 65536K
Total Submissions: 59643 Accepted: 22101
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
题意：这个题的意思是问你冒泡排序中交换值的次数，也就是让你求序列中的逆数对之和；

求在数列的逆序数可以使用归并排序。归并排序是将数列a[l,h]分成两半a[l,mid]和a[mid+1,h]分别进行归并排序，然后再将这两半合并起来。在合并的过程中（设l<=i<=mid，mid+1<=j<=h），当a[i]<=a[j]时，并不产生逆序数；当a[i]>a[j]时，在前半部分中比a[i]大的数都比a[j]大，将a[j]放在a[i]前面的话，逆序数要加上mid+1-i。因此，可以在归并排序中的合并过程中计算逆序数

这个代码好像只能在pku上ac；那就粘贴第二份代码，这是重做之后发现的错误

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
int n;
int A[500005],T[500005];
__int64 ans;
void mersort(int x,int y)
{
    if(y-x<=1)
        return;
    int mid=(x+y)/2;
    mersort(x,mid);
    mersort(mid,y);
    int p=x,i=x,q=mid;
    while(p<mid||q<y)
    {
        if(q==y||(p<mid&&A[p]<=A[q]))
            T[i++]=A[p++];
        else if(p==mid||(A[q]<A[p]))
        {
            if(p<mid) ans+=(mid-p);
            T[i++]=A[q++];
        }
    }
    for(int i=x; i<y; i++)
    {
        A[i]=T[i];
    }
}
int main()
{
    while(~scanf("%d",&n)&&n)
    {
        memset(A,0,sizeof(A));
        memset(T,0,sizeof(T));
        for(int i=0; i<n; i++)
        {
            scanf("%d",&A[i]);
        }
        ans=0;
        mersort(0,n);
        printf("%I64d\n",ans);
    }
    return 0;
}

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
#define LL long long int
int a[500005],b[500005];
int n;
LL ans;//极限情况500000*500000会爆，所以开LL
void mersort(int x,int y)
{
    if(y-x<=1)
        return ;
    int mid=(x+y)/2;
    mersort(x,mid);
    mersort(mid,y);
    int p=x,i=x,q=mid;
    while(p<mid||q<y)
    {
        if(q==y||(p<mid&&a[p]<=a[q]))//注意，不是a[p]<=a[mid],弄清比较的对象
        //x到y排序，所以应该和a[q]比，从而把后面的一到前面去。
            b[i++]=a[p++];
        else if(p==mid||a[p]>a[q])
        {
            if(p<mid) ans+=(mid-p);
            b[i++]=a[q++];
        }
    }
    for(int i=x; i<y; i++)
        a[i]=b[i];
}
int main()
{
    while(~scanf("%d",&n)&&n)
    {
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        for(int i=0; i<n; i++)
            scanf("%d",&a[i]);
        ans=0;
        mersort(0,n);
        printf("%lld\n",ans);
    }
    return 0;
}