Ultra-QuickSort（树状数组求逆序对）

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

对一个序列完成排序的最少交换次数即此序列中包含的逆序对的个数，因为该题目给定的值太大，数组开不出来，因此需要加入离散化的过程，考察树状数组求逆序对。 

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <cmath>
#include <algorithm>
#include <set>
#include <queue>
#include <string>
#include <map>
#define MAXN 500004
#define MOD 1000000009
#define INF 0x7ffffff
#define lowbit(x) (x)&(-x)

using namespace std;


int n;
struct Node{
    int val;
    int pos;
}a[MAXN];

int tree[MAXN];

int b[MAXN];

bool cmp(Node a,Node b){
    return a.val < b.val;
}

void add(int k,int num){
    while(k <= n){
        tree[k] += num;
        k += lowbit(k);
    }
}

long long getsum(int k){
    int sum = 0;
    while(k > 0){
        sum += tree[k];
        k -= lowbit(k);
    }
    return sum;
}

int main(){
    while(cin >> n && n){
        memset(tree,0,sizeof(tree));
        memset(b,0,sizeof(b));
        for(int i=1;i<=n;++i){
            cin >> a[i].val;
            a[i].pos = i;
        }
        sort(a+1,a+1+n,cmp);
        int cnt = 1;
        for(int i=1;i<=n;++i){
            if(i != 1 && a[i].val != a[i-1].val) ++cnt;
            b[a[i].pos] = cnt;
        }
        long long sum = 0;//逆序对的数量往往是一个大数，用LL型
        for(int i=1;i<=n;++i){
            add(b[i],1);
            sum += i-getsum(b[i]);
        }
        cout << sum << endl;
    }
    return 0;
}