树状数组之求逆对数

 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

题目是求每个数前面比它大的数量的总和，就是逆对数了。只要是离散化就可以做了。i-query(index[i])：当前是对i个数，query(index[i])是它前面比它小的数，减去它就是前面比它大的数量了。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define lowbit(x) x&(-x)
#define ll long long
using namespace std;
const int MAX = 5e5+5;
int n, tree[MAX],index[MAX];
struct Nod{
    int num,id;
}nod[MAX];
bool cmp(Nod a, Nod b){
    return a.num < b.num;
}
void add(int x, int y){
    while(x < MAX){
        tree[x] += y;
        x += lowbit(x);
    }
}

int query(int x){
    int sum = 0;
    while(x > 0){
        sum += tree[x];
        x -= lowbit(x);
    }
    return sum;
}
int main(){
    while(scanf("%d",&n)&&n){
        for(int i = 1; i <= n; i ++){
            scanf("%d",&nod[i].num);
            nod[i].id = i;
        }
        sort(nod+1,nod+1+n,cmp);
        for(int i = 1; i <= n; i ++)index[nod[i].id] = i;
        memset(tree,0,sizeof(tree));
        ll ans = 0;
        for(int i = 1; i <= n; i ++){
            add(index[i],1);
            //printf("%d+++++%d\n",index[i],query(index[i]));
            ans += i-query(index[i]);
        }
        printf("%lld\n",ans);
    }
}

 

 

 

Enemy is weak

 

 

The Romans have attacked again. This time they are much more than the Persians but Shapur is ready to defeat them. He says: "A lion is never afraid of a hundred sheep".

Nevertheless Shapur has to find weaknesses in the Roman army to defeat them. So he gives the army a weakness number.

In Shapur's opinion the weakness of an army is equal to the number of tripletsi, j, k such that i < j < k and a_i > a_j > a_k where a_x is the power of man standing at position x. The Roman army has one special trait — powers of all the people in it are distinct.

Help Shapur find out how weak the Romans are.

Input

The first line of input contains a single number n (3 ≤ n ≤ 10⁶) — the number of men in Roman army. Next line contains n different positive integers a_i (1 ≤ i ≤ n, 1 ≤ a_i ≤ 10⁹) — powers of men in the Roman army.

Output

A single integer number, the weakness of the Roman army.

Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).

Example

Input

3
3 2 1

Output

1

Input

3
2 3 1

Output

0

Input

4
10 8 3 1

Output

4

Input

4
1 5 4 3

Output

1


这个就是求三个递增的数量，也可以看成第i个数，求前面比它大的数量和后面比它小的数量。下面k是前面比它大的数量，
求后面比它小的数量：由于k是第i个数前面比第i个数大的数量，所以后面比第i个数小的数量
                 为(n-index[i])-(i-1-k)就是n-i-index[i]+k+1,(n-index[i])是比第i个数小的
                 总数，把它减去前面比第i个数小的数量就是后面的数量了，前面比第i个数小的
                 数量为(i-1-k),所以(n-index[i])-(i-1-k)就推来了

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define lowbit(x) x&(-x)
#define ll long long
using namespace std;
const int MAX = 1e6+10;
int n,tree[MAX],index[MAX];
int nex[MAX],pre[MAX];
struct Nod{
    int val,id;
}nod[MAX];
bool cmp(Nod a, Nod b){
    return a.val > b.val;
}
void add(int x){
    while(x < MAX){
        tree[x] ++;
        x += lowbit(x);
    }
}
int query(int x){
    int sum = 0;
    while(x > 0){
        sum += tree[x];
        x -= lowbit(x);
    }
    return sum;
}
int main(){
    scanf("%d",&n);
    for(int i = 1; i <= n; i ++)scanf("%d",&nod[i].val),nod[i].id=i;
    sort(nod+1,nod+1+n,cmp);
    for(int i = 1; i <= n; i ++)index[nod[i].id] = i;
    ll ans = 0,k;
    
    for(int i = 1; i <= n; i ++){
        k = query(index[i]);
        ans += k*(n-i-index[i]+k+1);
        add(index[i]);
    }
    cout << ans << endl;
    return 0;
}