ZOJ-2386 Ultra-QuickSort 【树状数组求逆序数+离散化】

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

 

---

 

 

题解：

树状数组求逆序数，先离散化，不然1e9开不下，然后每次对一个数id[i]，将树状数组中这个位置+1,统计这个位置的前缀和，然后用i-sum(id[i])(差实际上就是id[i]位置后缀和)就是这个数id[i]导致的逆序对数量。

 

代码:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define M(a, b) memset(a, b, sizeof(a))
const int N = 5e5 + 10;
int c[N], id[N], n;
struct node {
    int val, pos;
    bool operator < (const node &rhs) const {
        return val < rhs.val;
    }
}a[N];

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

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

int sum(int x) {
    long long ret = 0;
    while (x) {
        ret += c[x];
        x -= lowbit(x);
    }
    return ret;
}

int main() {
    while (scanf("%d", &n), n) {
        M(c, 0);
        for (int i = 1; i <= n; ++i)
            scanf("%d", &a[i].val), a[i].pos = i;
        sort(a+1, a+1+n);
        for (int i = 1; i <= n; ++i) id[a[i].pos] = i;
        long long ans = 0;
        for (int i = 1; i <= n; ++i) {
            add(id[i], 1);
            ans += i-sum(id[i]);
        }
        printf("%lld\n", ans);
    }

    return 0;
}