POJ 2299 树状数组+离散化

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

题目大意：给你一个序列，你只能移动相邻的两个数，使得最终得到的序列是从小到大的顺序排列的，求最小的移动次数

变相的求逆序数，可以用树状数组来操作求逆序数（在第一个样例中是   1,0   5,4   9,1    9,0     9,5     9,4），由于树状数组是通过二进制来操作实现的,没有办法存储所给的数据，所以需要离散化

#include<iostream>
#include<cstring>
#include <algorithm>
using namespace std;
const int mod =1e9+7;
typedef long long ll;
ll n;
ll c[500010];
ll a[500010];//a[i]的范围太大，放不进c数组，因此需要离散化
struct node
{
    int val;//存储原来的数值
    int id;//存储下标
    bool operator < (const node &a) const
    {
        return val < a.val;
    }
}num[500010];
int lowbit(int a)
{
    return a&-a;
}
void add(int x)
{
    while(x<=n)
    {
        c[x]+=1;
        x+=lowbit(x);
    }
}
int sum(int x)
{
    int res=0;
    while(x>0)
    {
        res+=c[x];
        x-=lowbit(x);
    }
    return res;

}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    while(cin>>n&&n)
    {
    memset(a,0,sizeof a);
   memset(c,0,sizeof c);
    memset(num,0,sizeof num);
    for(int i=1;i<=n;i++)
        cin>>num[i].val,num[i].id=i;
        sort(num+1,num+1+n);//先排一下顺序，从小到大排，为离散做准备
//        for(int i=1;i<=n;i++)
//            cout<<num[i].val<<" ";
        for(int i=1;i<=n;i++)//开始离散
            a[num[i].id]=i;//因为输入的数据是没有重复的，因此可以将其数据范围缩小
    ll ans=0;//为什么离散之后还是能够保证答案的正确性呢？因为我们要看逆序数有多少，只要知道
//它们的排列大小顺序就行，而不用管到底是多大的数，比如100000 1 2和10 1 2不是一个意思吗，都含
//一个逆序数，然后下面的步骤就是建立树状数组，只用a数组就可以了
     for(int i=1;i<=n;i++)
     {
        add(a[i]);//每次都树状数组赋值，因为树状数组是向后更替的，如果输入的数越小，遍历+1的就 //越多,如果前三个都比第四个小，那么在i-sum(a[i])就是0
        ans+=i-sum(a[i]);//sum(a[i])是求前面比a[i]小的个数，i-sum(a[i])就是求比a[i]大的
//个数
     }
     cout<<ans<<endl;
    }
    return 0;
}

其实这个数状数组就是一种特殊排列的一种数组，其本质还是数组，只不过我们把它模拟成一种树的形状而已，要时刻明白它的二级制的转换求其add与sum模板函数的意思。一个参考详细的传送