POJ2299-Ultra-QuickSort

Ultra-QuickSort

Time Limit: 7000MS		Memory Limit: 65536K
Total Submissions: 56022		Accepted: 20697

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

题意：给出长度为n的序列，每次只能交换相邻的两个元素，问至少要交换几次才使得该序列为递增序列。

解题思路：一个乱序序列的 逆序数 = 在只允许相邻两个元素交换的条件下,得到有序序列的交换次数

#include <iostream>
#include <cstdio>
#include <cstring>
#include <stack>
#include <queue>
#include <cmath>
#include <algorithm>

using namespace std;

const int maxn=501000;
struct node
{
    long long int x;
    int y;
}a[maxn];
int n,b[maxn],t;
long long int f[maxn];

bool cmp(node a,node b)
{
    return (a.x<b.x||(a.x==b.x && a.y<b.y));
}

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

long long q(int x)
{
    long long int tmp=0;
    while (x>0)
    {
        tmp+=f[x];
        x-=lowb(x);
    }
    return tmp;
}

void add(int x)
{
    while(x<=n)
    {
        f[x]++;
        x+=lowb(x);
    }
}

int main()
{
    while(~scanf("%d",&n)&&n)
    {
        for (int i=1; i<=n; i++)
        {
            scanf("%I64d",&a[i].x);
            a[i].y=i;
        }
        t=0;
        sort(a+1,a+1+n,cmp);
        a[0].x=-1;
        for (int i=1;i<=n;i++)
        {
            if (a[i].x!=a[i-1].x) t++;
            b[a[i].y]=t;
        }
        memset(f,0,sizeof(f));
        long long int ans=0;
        for (int i=1;i<=n;i++)
        {
            ans+=(q(n)-q(b[i]));
            add(b[i]);
        }
        cout<<ans<<endl;
    }
    return 0;
}