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 Rust (judge verdict: Accepted)

use std::io::*;
use std::str::FromStr;

#[allow(unused_macros)]
macro_rules! scan {
  ($e:expr; $t:ty) => {
    $e.get::<$t>()
  };
  ($e:expr; $($t:ty), *) => {
    ($($e.get::<$t>(),)*)
  };
  ($e:expr => $i:expr; $t:ty) => {
    (0..$i).map(|_| $e.get::<$t>()).collect::<Vec<$t>>()
  };
  ($e:expr => $row:expr, $col:expr; $t:ty) => {
    (0..$i).map(|_| scan!($e => $col; $t)).collect::<Vec<$t>>()
  }
}

struct Scanner<R: Read> {
  reader: R
}

#[allow(dead_code)]
impl<R: Read> Scanner<R> {
  fn new(reader: R) -> Scanner<R> {
    Scanner { reader: reader }
  }
  fn safe_get<T: FromStr>(&mut self) -> Option<T> {
    let token = self.reader.by_ref().bytes().map(|c| c.unwrap() as char)
      .skip_while(|c| c.is_whitespace())
      .take_while(|c| !c.is_whitespace())
      .collect::<String>();
    if token.is_empty() { None } else { token.parse().ok() }
  }
  fn get<T: FromStr>(&mut self) -> T {
    if let Some(v) = self.safe_get() { v } else {
      writeln!(stderr(), "Terminated with EOF").unwrap();
      std::process::exit(0);
    }
  }
}

fn merge(vec: &mut Vec<i32>, left: usize, mid: usize, right: usize) -> i64 {
  let n1 = mid - left;
  let n2 = right - mid;
  let mut l = Vec::with_capacity(n1 + 1);
  let mut r = Vec::with_capacity(n2 + 1);
  for i in 0..n1 {
    l.push(vec[left + i]);
  }
  for i in 0..n2 {
    r.push(vec[mid + i]);
  }
  l.push(std::i32::MAX);
  r.push(std::i32::MAX);
  let mut ans = 0;
  let (mut i, mut j) = (0, 0);
  for k in left..right {
    if l[i] <= r[j] {
      vec[k] = l[i];
      i += 1;
    }
    else {
      vec[k] = r[j];
      j += 1;
      ans += l.len() - 1 - i;
    }
  }
  ans as i64
}

fn merge_sort(vec: &mut Vec<i32>, left: usize, right: usize) -> i64 {
  let mut ans = 0;
  if left + 1 < right {
    let mid = (left + right) / 2;
    ans += merge_sort(vec, left, mid);
    ans += merge_sort(vec, mid, right);
    ans += merge(vec, left, mid, right);
  }
  ans
}

fn main() {
  let cin = stdin();
  let cin = cin.lock();
  let mut sc = Scanner::new(cin);
  let n = scan!(sc; usize);
  let mut a = scan!(sc => n; i32);
  println!("{}", merge_sort(&mut a, 0, n))
}