【树状数组--求逆序数（离散化）】poj2299 Ultra-QuickSort

Ultra-QuickSort

Time Limit: 7000MS		Memory Limit: 65536K
Total Submissions: 61575		Accepted: 22868

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

题意：这就是一个裸的求逆序数的题目，不过注意数据范围是999999999，会超数组的范围啊，再看数据N顶多500000，所以离散化一下数组就可以放得下了；

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;

const int N=500005;
ll C[N];
struct node
{
    ll i,value;
}a[N];

int cmp1(node a,node b)
{
    if(a.value!=b.value)
        return a.value<b.value;
    return a.i<b.i;
}

int cmp2(node a,node b)
{
    return a.i<b.i;
}

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

ll sum(int x)
{
    ll ret=0;
    while(x>0)
    {
        ret+=C[x];
        x-=lowbit(x);
    }
    return ret;
}

void add(int x,int d)
{
    while(x<=N)
    {
        C[x]+=d;
        x+=lowbit(x);
    }
}

int main()
{
    int n;
    while(scanf("%d",&n),n)
    {
        //pre;
        memset(a,0,sizeof(a));
        memset(C,0,sizeof(C));

        //input;
        for(int i=1;i<=n;i++)
        {
            scanf("%lld",&a[i].value);
            a[i].i=i;
        }

        //离散化；
        sort(a+1,a+1+n,cmp1);
        for(int i=1;i<=n;i++)
            a[i].value=i;
        sort(a+1,a+1+n,cmp2);
//        for(int i=1;i<=n;i++)
//            printf("%d ",a[i].value);

        //calcu;
        ll ans=0;
        for(int i=1;i<=n;i++)
        {
//            printf("%d\n",i);
            ll x=i-1-sum(a[i].value);
//            printf("%d\n",x);
            ans+=x;
            add(a[i].value,1);
        }

        //output;
        printf("%lld\n",ans);
    }
    return 0;
}