Problem:
Score : 700 points

Problem Statement

We have N cards numbered 1, 2, ..., N.
Card i (1 \leq i \leq N) has an integer A_i written in red ink on one side and an integer B_i written in blue ink on the other side.
Initially, these cards are arranged from left to right in the order from Card 1 to Card N, with the red numbers facing up.

Determine whether it is possible to have a non-decreasing sequence facing up from left to right (that is, for each i (1 \leq i \leq N - 1), the integer facing up on the (i+1)-th card from the left is not less than the integer facing up on the i-th card from the left) by repeating the operation below. If the answer is yes, find the minimum number of operations required to achieve it.

Choose an integer i (1 \leq i \leq N - 1).
Swap the i-th and (i+1)-th cards from the left, then flip these two cards.

Constraints

1 \leq N \leq 18

1 \leq A_i, B_i \leq 50 (1 \leq i \leq N)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N
B_1 B_2 ... B_N

Output

If it is impossible to have a non-decreasing sequence, print -1.
If it is possible, print the minimum number of operations required to achieve it.

Sample Input 1

3
3 4 3
3 2 3

Sample Output 1

1

By doing the operation once with i = 1, we have a sequence [2, 3, 3] facing up, which is non-decreasing.

Sample Input 2

2
2 1
1 2

Sample Output 2

-1

After any number of operations, we have the sequence [2, 1] facing up, which is not non-decreasing.

Sample Input 3

4
1 2 3 4
5 6 7 8

Sample Output 3

0

No operation may be required.

Sample Input 4

5
28 15 22 43 31
20 22 43 33 32

Sample Output 4

-1

Sample Input 5

5
4 46 6 38 43
33 15 18 27 37

Sample Output 5

3

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

fn main() {
	let mut s = String::new();
	use std::io::Read;
	std::io::stdin().read_to_string(&mut s).unwrap();
	let mut s = s.split_whitespace();
	let n: usize = s.next().unwrap().parse().unwrap();
	let a: Vec<i16> = s.by_ref().take(n).map(|a| a.parse().unwrap()).collect();
	let b: Vec<i16> = s.map(|a| a.parse().unwrap()).collect();
	let mut ans = std::usize::MAX;
	'pat: for pattern in 0..1 << n {
		let mut target: Vec<_> = a.iter().zip(b.iter()).enumerate().map(|(i, (a, b))| if (pattern >> i) & 1 == 0 { (*a, (i, false)) } else { (*b, (i, true)) }).collect();
		target.sort();
		let mut dummy = vec![0; n];
		let mut l = 0;
		while l < target.len() {
			let mut r = l;
			while r < target.len() && target[l].0 == target[r].0 { r += 1; }
			let mut unused: usize = ((1 << r) - 1) ^ ((1 << l) - 1);
			for i in l..r {
				for j in unused.trailing_zeros() as usize..r {
					if (unused >> j) & 1 == 0 { continue; }
					if ((target[i].1 .0 as i8 - j as i8) & 1 == 1) == target[i].1 .1 {
						dummy[target[i].1 .0] = j;
						unused ^= 1 << j;
					}
				}
			}
			if unused != 0 { continue 'pat; }
			l = r;
		}
		let cnt = count(&dummy);
		if cnt < ans { ans = cnt; }
	}
	println!("{}", if ans == std::usize::MAX { -1 } else { ans as i16 });
}

fn count(a: &[usize]) -> usize {
	let mut bit = BIT::new(a.len());
	a.iter().enumerate().fold(0, |r, (i, &a)|{
		bit.add(a, 1);
		r + (i + 1) - bit.sum(a + 1) as usize
	})
}

struct BIT<T> {
	data: Vec<T>
}

impl<T> BIT<T>
where
	T: Clone + Default + std::ops::AddAssign
{
	fn new(n: usize) -> BIT<T> {
		BIT { data: vec![T::default(); n + 1] }
	}
	fn sum(&self, i: usize) -> T {
		let mut r = T::default();
		let mut i = i;
		while i > 0 {
			r += self.data[i].clone();
			i &= i - 1;
		}
		r
	}
	fn add(&mut self, i: usize, value: T) {
		let mut i = i + 1;
		while i < self.data.len() {
			self.data[i] += value.clone();
			i += i & (!i + 1);
		}
	}
}