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 C (GCC 5.4.1) (judge verdict: Wrong Answer)

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

#define EMPTY 0
#define FULL 1
#define DELETED 2
 
#define INF 1000000000
 
#define min(a,b) (((a)<(b))?(a):(b))
#define max(a,b) (((a)>(b))?(a):(b))

typedef struct {
	long key;
	long pos;
} Data;

Data data[300010];
int state[300010] = {0};

long hash(long key, long count) {
	return (key + count) % 300007;
}

void insert(long key, long pos) {
	int i, k;
	
	i = 0;
	k = hash(key, i++);
	while(state[k] == FULL) {
		k = hash(key, i++);
	}
	
	data[k].key = key;
	data[k].pos = pos;
	state[k] = FULL;
}

long search(long key) {
	int i, k;
	
	i = 0;
	k = hash(key, i++);
	while(state[k] != EMPTY) {
		if(state[k] == FULL && data[k].key == key) {
			return data[k].pos;
		}
		k = hash(key, i++);
	}
	
	return -1;
}

int compare_long(const void *a, const void *b) {
	return *(long*)a - *(long*)b;
}

int main() {
	long N;
	long A[100001];
	long B[100001];
	long even[100001];
	long odd[100001];
	long ce = 0, co = 0;
	long i, j;
	long ans = 0;
	long m = 0;
	long test = 0;
	long tmp;
	
	scanf("%ld", &N);
	for(i=0;i<N;i++) {
		scanf("%ld", &A[i]);
		B[i] = A[i];
		if(i % 2) odd[co++] = A[i];
		else even[ce++] = A[i];
	}
	
	qsort(A, N, sizeof(long), compare_long);
	qsort(even, ce, sizeof(long), compare_long);
	qsort(odd, co, sizeof(long), compare_long);
	
	for(i=0;i<N;i++) {
		insert(A[i], i);
	}
	
	for(i=0;i<ce;i++) {
		ans += labs(search(even[i]) - 2*i);
	}
	
	for(i=0;i<N-1;i++) {
		if(i % 2) {
			if(search(B[i]) % 2 == 0 && search(B[i+1]) % 2) {
				test++;
				tmp = B[i];
				B[i] = B[i+1];
				B[i+1] = tmp;
			}
		} else {
			if(search(B[i]) % 2 && search(B[i+1]) % 2 == 0) {
				test++;
				tmp = B[i];
				B[i] = B[i+1];
				B[i+1] = tmp;
			}
		}
	}
	
	ce = co = 0;
	for(i=0;i<N;i++) {
		if(i % 2) odd[co++] = B[i];
		else even[ce++] = B[i];
	}
	qsort(even, ce, sizeof(long), compare_long);
	qsort(odd, co, sizeof(long), compare_long);
	
	for(i=0;i<co;i++) {
		test += labs(search(odd[i]) - (2*i + 1));
	}
	
	printf("%ld\n", min(ans, test));
	
	return 0;
	
}