Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

The Number of Inversions

For a given sequence $A = \{a_0, a_1, ... a_{n-1}\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:

bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++

return cnt

For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.

Input

In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.

output

Print the number of inversions in a line.

Constraints

$ 1 \leq n \leq 200,000$

$ 0 \leq a_i \leq 10^9$

$a_i$ are all different

Sample Input 1

5
3 5 2 1 4

Sample Output 1

6

Sample Input 2

3
3 1 2

Sample Output 2

2

Solution in C (judge verdict: Time Limit Exceeded)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>

//============================================================================
#define pred(x) ((x)-1)
#define succ(x) ((x)+1)
//============================================================================
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
struct node {
    long num; struct node *left, *right;
};
//----------------------------------------------------------------------------
typedef struct node NODE;
//----------------------------------------------------------------------------
long Value,Cnt;
//----------------------------------------------------------------------------
char *my_alloc(int n)
{
    char *p;

    p = malloc(n);
    if (p == NULL){
        printf("Not enough memory\n"); exit(1);
    }
    return p;
}
//----------------------------------------------------------------------------
long countnode(NODE *p)
{
    long cnt=1;

    if (p==NULL)
        return 0;
    if (p->left==NULL && p->right==NULL)
       return cnt;
    if (p->left!=NULL)
        cnt+=countnode(p->left);
    if (p->right!=NULL)
        cnt+=countnode(p->right);
    return cnt;
}
//----------------------------------------------------------------------------
NODE *addnode(NODE *p)
{
    char *my_alloc();

    if (p == NULL){
        p = (NODE *)my_alloc(sizeof(NODE));
        p->num=Value;
        p->left = p->right = NULL;
    }else{
        if (Value< p->num){
            Cnt++;
            Cnt+=countnode(p->right);
            p->left = addnode(p->left);
        }else if (Value> p->num)
            p->right = addnode(p->right);
    }
    return p;
}
//----------------------------------------------------------------------------
void deltree(NODE **pp)
{
    if (*pp != NULL){
        deltree(&(*pp)->left); deltree(&(*pp)->right);
        free(*pp);
        *pp=NULL;
    }
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void input(FILE *file)
{
    long n,i; NODE *root;

    fscanf(file, "%ld", &n);
    for (i=Cnt=0, root=NULL; i<n; i++){
        fscanf(file, "%ld", &Value);
        root=addnode(root);
    }
    printf("%ld\n", Cnt);
    deltree(&root);
}
//============================================================================
#ifndef DESKTOP
int main()
{
    input(stdin);
    return 0;
}
#endif