POJ-2299 Ultra-QuickSort （树状数组，离散化，C++）

Problem 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

 

 

很有意思的一道题，首先看图片就像一个通马桶的工具。

这里只提及树状数组。

 

 

这道题考的考点是数据的处理，逆序数。

所以思路来了，逆序数不就比大小吗，直接就标上序号，来一个排序加上数据处理，OK！ 

数据处理的方法网上一般称之为离散化，我对离散化的理解就是简化问题，使一个连续（不可解）的问题变得离散（可解）。

本题考的就是数据，直接加和会爆炸。于是用123......n，表示这些数的价值就变得可解，这个过程算是离散化。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define MAX 500050
typedef long long ll;
int a[MAX];
int c[MAX];
 
struct node
{
    int num;
    ll v;
    bool operator < (const node &b ) const     //重载一下运算符，这里的const可加可不加，对于不同编译器是有区别的
    {
        return v<b.v;
    }
 
}b[MAX];
int lowbit(int i)
{
    return i&(-i);
}
void add(int x,int v)
{
    while(x<=MAX)
    {
        c[x]+=v;
        x+=lowbit(x);
    }
}
int sum(int x)
{
    int res=0;
    while(x>0)
    {
        res+=c[x];
        x-=lowbit(x);
    }
    return res;
}
int main()
{
    int n;
    while(scanf("%d",&n),n)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&b[i].v);
 
            b[i].num=i;
        }
 
        sort(b+1,b+n+1);    //值排序
        memset(a,0,sizeof(a));
        a[b[1].num]=1;      //对于最小值当然标最小啦
        ll ans=0;
 
        for(int i=2;i<=n;i++)
        {
            if(b[i].v==b[i-1].v)
                a[b[i].num]=a[b[i-1].num];
            else
                a[b[i].num]=i;        // 记录前面比他小的数。
        }
        memset(c,0,sizeof(c));
        for(int i=1;i<=n;i++)
        {
            add(a[i],1);
            ans+=sum(n)-sum(a[i]);
 
        }
        printf("%lld\n",ans);
    }
}