Problem:
Score : 600 points

Problem Statement

Snuke got an integer sequence of length N from his mother, as a birthday present. The i-th (1 ≦ i ≦ N) element of the sequence is a_i. The elements are pairwise distinct.
He is sorting this sequence in increasing order.
With supernatural power, he can perform the following two operations on the sequence in any order:

Operation 1: choose 2 consecutive elements, then reverse the order of those elements.

Operation 2: choose 3 consecutive elements, then reverse the order of those elements.

Snuke likes Operation 2, but not Operation 1. Find the minimum number of Operation 1 that he has to perform in order to sort the sequence in increasing order.

Constraints

1 ≦ N ≦ 10^5

0 ≦ A_i ≦ 10^9

If i ≠ j, then A_i ≠ A_j.

All input values are integers.

Input

The input is given from Standard Input in the following format:

N
A_1
:
A_N

Output

Print the minimum number of times Operation 1 that Snuke has to perform.

Sample Input 1

4
2
4
3
1

Sample Output 1

1

The given sequence can be sorted as follows:

First, reverse the order of the last three elements. The sequence is now: 2,1,3,4.

Then, reverse the order of the first two elements. The sequence is now: 1,2,3,4.

In this sequence of operations, Operation 1 is performed once. It is not possible to sort the sequence with less number of Operation 1, thus the answer is 1.

Sample Input 2

5
10
8
5
3
2

Sample Output 2

0

Solution in Rust (1.15.1) (judge verdict: Accepted)

#![allow(non_snake_case,unused_imports,dead_code)]
use std::io::Read;
use std::cmp::max;
use std::cmp::min;
use std::str::FromStr;
use std::collections::HashMap;
use std::collections::HashSet;
use std::collections::BinaryHeap;

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();
    let mut buf_it = buf.split_whitespace();

    let N = buf_it.next().unwrap().parse::<usize>().unwrap();
    let A = (0..N).map(|_| buf_it.next().unwrap().parse::<isize>().unwrap()).collect::<Vec<_>>();

    let mut B = A.clone();
    B.sort();
    
    let mut Ae = HashMap::new();
    let mut Ao = HashMap::new();
    let mut Be = HashMap::new();
    let mut Bo = HashMap::new();


    for i in 0..N{
        let a = A[i];
        let b = B[i];
        if i%2==0{
            let n:isize = *Ae.get(&a).unwrap_or(&0);
            let m:isize = *Be.get(&b).unwrap_or(&0);
            Ae.insert(a,n+1);
            Be.insert(b,m+1);
        } else {
            let n:isize = *Ao.get(&a).unwrap_or(&0);
            let m:isize = *Bo.get(&b).unwrap_or(&0);
            Ao.insert(a,n+1);
            Bo.insert(b,m+1);
        }
    }

    let mut ans = 0;
    for (k,v) in Ae.into_iter(){
        let n = *Be.get(&k).unwrap_or(&0);
        ans += (v-n).abs();
    }
    println!("{}",ans);
}