poj2299树状数组入门

Ultra-QuickSort

Time Limit: 7000MS		Memory Limit: 65536K
Total Submissions: 78351		Accepted: 29398

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

菜鸡的我差点没被这题给逼疯（看别人的都看不懂，我也是够啦）（用树状数组做的罪魁祸首）

网上大神说的：撇开细节，这是最基本的树状数组代码，我的理解是把数据大小以二进制的思想排列，我们平时是以十进制的思想排列数组，如果不理解没关系，我也不是很懂，上面这样的代码是做了件这样的事：build把一个数据按顺序插入树中，get_sum判断一个数据在树中有多少个数据不大于它。这可以用暴力去理解，但无法用暴力的方法去做，会超时。

然后思考这个东西有什么用？要求的是交换次数，也就是说我们只要知道顺序，数据的值无所谓，容易得到排好序的结果：

9 1 0 5 4 ——> 0 1 4 5 9

我们保留原位置的标号，例如（9 1 0 5 4）的标号（1 2 3 4 5），排序后就是（5 2 1 4 3），再用上述的树状数组就会得到（1 1 1 3 3），而如果一开始的数据是排好的，如果输入的是（0 1 4 5 9），那么排序后标号（1 2 3 4 5），树状结果（1 2 3 4 5），差异就在这，很明显（1 2 3 4 5）就是排列好的结果，这与（1 1 1 3 3）的差值就是需要移动的次数。这还要记住一点，移动是不会改变其他逆序对的。
 

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<string.h>
#include<iterator>
#include<vector>
#include<stdlib.h>
#include<map>
#include<queue>
#include<stack>
#include<set>
#include<sstream>
#define lowbit(x) (x&(-x))
typedef long long ll;
using namespace std;
const int N = 5e5+10;
int num[N],tree[N];
int n;
ll sum = 0;
struct node
{
    int value,sign;
}arr[N];
void build(int x)
{
    for(int i=x;i<=n;i+=lowbit(i))//把数据按顺序插入到树中
        tree[i]++;
}
int getsum(int x)//判断一个数据中有多少个数据不大于它
{
    int res  = 0;
    for(int i=x;i>=1;i-=lowbit(i))
        res+=tree[i];
    return res;
}
bool cmp(node n1,node n2)
{
    return n1.value<n2.value;
}
int main()
{
    while(scanf("%d",&n),n)
    {
        sum = 0;
        memset(tree,0,sizeof(tree));
        for(int i=1;i<=n;i++){
            scanf("%d",&arr[i].value);
            arr[i].sign = i;
    }
    sort(arr+1,arr+n+1,cmp);
    for(int i=1;i<=n;i++)
        num[arr[i].sign] = i;
    for(int i=1;i<=n;i++){
        build(num[i]);
        sum+=i-getsum(num[i]);
    }
    printf("%lld\n",sum);
    }
    return 0;
}