test tle print integer += log operator 有意思 produce

Problem 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 很有意思的一道題，首先看圖片就像一個通馬桶的工具。 這裏只提及樹狀數組。 這道題考的考點是數據的處理，逆序數。 所以思路來了，逆序數不就比大小嗎，直接就標上序號，來一個排序加上數據處理，OK！ 數據處理的方法網上一般稱之為離散化，我對離散化的理解就是簡化問題，使一個連續（不可解）的問題變得離散（可解）。 本題考的就是數據，直接加和會爆炸。於是用123......n，表示這些數的價值就變得可解，這個過程算是離散化。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define MAX 500050
typedef long long ll;
int a[MAX];
int c[MAX];

struct node
{
    int num;
    ll v;
    bool operator < (const node &b ) const     //重載一下運算符，這裏的const可加可不加，對於不同編譯器是有區別的
    {
        return v<b.v;
    }

}b[MAX];
int lowbit(int i)
{
    return i&(-i);
}
void add(int x,int v)
{
    while(x<=MAX)
    {
        c[x]+=v;
        x+=lowbit(x);
    }
}
int sum(int x)
{
    int res=0;
    while(x>0)
    {
        res+=c[x];
        x-=lowbit(x);
    }
    return res;
}
int main()
{
    int n;
    while(scanf("%d",&n),n)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&b[i].v);

            b[i].num=i;
        }

        sort(b+1,b+n+1);    //值排序
        memset(a,0,sizeof(a));
        a[b[1].num]=1;      //對於最小值當然標最小啦
        ll ans=0;

        for(int i=2;i<=n;i++)
        {
            if(b[i].v==b[i-1].v)
                a[b[i].num]=a[b[i-1].num];      
            else
                a[b[i].num]=i;        // 記錄前面比他小的數。
        }
        memset(c,0,sizeof(c));
        for(int i=1;i<=n;i++)
        {
            add(a[i],1);
            ans+=sum(n)-sum(a[i]);

        }
        printf("%lld\n",ans);
    }
}

　　

POJ-2299 Ultra-QuickSort （樹狀數組，離散化，C++）