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

树状数组的简单应用，就是离散化。
一开始拿到这道题，
正常的思路就是 先给这个数字按照输入的顺序排序，然后再按照值排序，然后用一个映射的数组 下标是输入的顺序，对应的值是离散化排序的值，然后按照输入的顺序从小到大从开始到结束，进行更新，然后用 i-getsum[i] 当前位置的i以及i在树状数组里面得到1到i的和。相减即可得逆序数

#include <iostream>
#include <algorithm> 
#include <cstdio>
#include <cstring>
#include <queue>
#include <string>
#include <map>
using namespace std;
int n;
typedef long long LL;
#define lowbit(x) ((x)&(-x))
struct node
{
    int val;
    int pos;
    bool operator < (const node &rhs) const
    {
        return val<rhs.val;
    }
}s[100010];
int c[100100];
int reflect[100100];
void update(int x)
{
    while(x<=n)
    {
        c[x]+=1;
        x+=lowbit(x);
    }
}
int getsum(int x)
{
    int sum=0;
    while(x>0)
    {
        sum+=c[x];
        x-=lowbit(x);
    }
    return sum;
}
int main()
{

    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&s[i].val);
            s[i].pos=i;
        }
        sort(s+1,s+1+n);
        for(int i=0;i<=n;i++) c[i]=0;
        int ans=0;
       for(int i=1;i<=n;i++) reflect[s[i].pos]=i;//离散化其实给这个数原来的位置重新排序。然后更新的时候for（旧位置）也就是用旧位置的顺序更新新位置的序号（reflect[i]).
       for(int i=1;i<=n;i++)
       {
        update(reflect[i]);
        ans+=i-getsum(reflect[i]);
       }
       printf("%d\n", ans);
    }
}