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 Kotlin (1.0.0) (judge verdict: Time Limit Exceeded)

import kotlin.system.exitProcess
var A: List<Int> = emptyList()
var B: List<Int> = emptyList()
var L: List<Int> = emptyList()
var ANS: Int = 0
fun main(args: Array<String>) {
    val N = nextInt()
    A = listOfInt()
    B = listOfInt()
    L = (0 .. (N-1)).map { it }
    ANS = Int.MAX_VALUE
    permutation(L, emptyList())
    println(if (ANS == Int.MAX_VALUE) -1 else ANS - 1)
}
fun next() = readLine()!!
fun nextInt(delta: Int = 0) = Integer.parseInt(next()) + delta
fun listOfString() = next().split(" ")
fun listOfInt(delta: Int = 0) = listOfString().map { Integer.parseInt(it) + delta }
fun make(ans: List<Int>) {
    var n = 0
    val a = Array<Int>(ans.size) {
        if (it == ans[it]) {
            A[it]
        } else {
            n += 1
            if (Math.abs(it - ans[it]) % 2 == 0) A[ans[it]] else B[ans[it]]
        }
    }
    var max = Int.MIN_VALUE
    val bood = a.all { if (max <= it) {
            max = it
            true
        } else false
    }
    if (bood) {
        if (n == 0) {
            println(0)
            exitProcess(0)
        }
        if (ANS > n) ANS = n
    }
}
fun permutation(q: List<Int>, ans: List<Int>) {
    if (q.size <= 1) {
        //println(ans + q)
        make(ans + q)
    } else {
        for (i in 0 until q.size) {
            permutation(
                q.subList(0, i) + q.subList(i + 1, q.size),
                ans + q[i]
            )
        }
    }
}