Ultra-QuickSort POJ

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

题意：将一个序列从小到大排序，如果只能交换相邻的数，最少需要交换多少次
思路：和冒泡排序一样，一个数需要交换的次数就是它的逆序对数，所以就是求总的逆序对的个数

求逆序对可以用两种方法
①归并排序：

#include<cstdio>
#include<iostream>
using namespace std;

int n;
const int maxn = 5e5+5;
int num[maxn];
typedef long long ll;

ll Mersort(int l,int r)
{
    int mid = (l+r)/2;
    int i=l,j=mid+1;
    int b[r-l+5];
    int k=1;
    ll ans = 0;
    while(i <= mid && j <= r)
    {
        if(num[i] <= num[j])
            b[k++] = num[i++];
        else
            b[k++] = num[j++],ans+=mid-i+1;
    }
    while(i <= mid)
    {
        b[k++] = num[i++];
    }
    while(j <= r)
    {
        b[k++] = num[j++];
    }
    for(int i=l; i<=r; i++)
    {
        num[i] = b[i-l+1];
    }
    return ans;
}

int Merge(int l,int r,ll  &ans)
{
    int mid = (l+r)/2;
    if(l == r)
        return 0;
    Merge(l,mid,ans);
    Merge(mid+1,r,ans);
    ans += Mersort(l,r);
}
int main()
{
    while(~scanf("%d",&n) && n)
    {
        for(int i=1; i<=n; i++)
            scanf("%d",&num[i]);
        ll  ans = 0;
        Merge(1,n,ans);
        printf("%lld
",ans);
    }
}

②树状数组：（要注意离散，离散可以二分，也可以map）

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;

const int maxn = 5e5+5;
int n;
int tree[maxn];
typedef long long ll;

int lowbit(int x)
{
    return x&(-x);
}

void add(int x)
{
    for(int i=x;i<=n;i+=lowbit(i))
    {
        tree[i]++;
    }
}

int Query(int x)
{
    int ans = 0;
    for(int i=x;i>0;i-=lowbit(i))
    {
        ans+=tree[i];
    }
    return ans;
}
int query(int x,int n,int *b)
{
    return lower_bound(b+1,b+1+n,x) - b;
}
int main()
{
    while(~scanf("%d",&n) && n)
    {
        memset(tree,0,sizeof(tree));
        int a[n+1],b[n+1];
        for(int i=1;i<=n;i++)scanf("%d",&a[i]),b[i] = a[i];
        sort(b+1,b+1+n);
        int len = unique(b+1,b+1+n)-b-1;
        ll ans = 0;
        for(int i=1;i<=n;i++)
        {
            int pos = query(a[i],len,b);
            add(pos);
            ans +=  pos - 1 - Query(pos-1);
        }
        printf("%lld
",ans);
    }
}