#!/usr/bin/env python3

from collections import defaultdict,deque

from heapq import heappush, heappop

from bisect import bisect_left, bisect_right

import sys, random, itertools, math

sys.setrecursionlimit(10**5)

input = sys.stdin.readline

sqrt = math.sqrt

def LI(): return list(map(int, input().split()))

def LF(): return list(map(float, input().split()))

def LI_(): return list([int(x)-1 for x in input().split()])

def II(): return int(eval(input()))

def IF(): return float(eval(input()))

def LS(): return list(map(list, input().split()))

def S(): return list(input().rstrip())

def IR(n): return [II() for _ in range(n)]

def LIR(n): return [LI() for _ in range(n)]

def FR(n): return [IF() for _ in range(n)]

def LFR(n): return [LI() for _ in range(n)]

def LIR_(n): return [LI_() for _ in range(n)]

def SR(n): return [S() for _ in range(n)]

def LSR(n): return [LS() for _ in range(n)]

mod = 1000000007

inf = 1e10



"""

URL : https://atcoder.jp/contests/keyence2020/tasks/keyence2020_d

解説AC



きもすぎBit全探索および転倒数

    （転倒数に結びついたら強い

    　隣通しを入れ替えてsortの操作数→バブルソートの操作数→転倒数

    　これの徹底）



AC例1: 最初に考え付いたのはこっち

    maskでどのindexが裏返しになっているかを保持。

    その状況下で生成される表面の数の配列を作成し(これをLとする)ソート。

    iを[0,n)で回して各A[i],B[i]に対して

    maskをもとにAかBが使用されているかを見る。

    Lにおけるその数のindexとiの差の偶奇は奇数B偶数ならA。

    defalutdictかなんかで各Lの数字とそのindexの偶奇の数とそのindexを保持

    indexとiの差の偶奇とdictからLの各indexが元どの番号にいたかを保持。

    あとは元の番号の配列の転倒数を求めればそのmaskにおける操作数が出る



AC例2: 解説はこっち

    maskではどのindexがすでに左側で固定化されたかを保持。

    巡回セールスマンのようにどこを決めて最後に決めたindexは何か

    というDPでいける。（は？）

    というのもmaskだけではそのマスク内の順番はわからないからね。

    欲しいのはその固定化された物の最大の値なので最悪なんかうまくできるかも

    すごすぎ

    こっちを実装します

    700点をACしたいね(2020/3/25/ 20:05)



    Reference: https://atcoder.jp/contests/keyence2020/submissions/9567775 By:yutaka1999

"""



#solve

def solve():

    n = II()

    A = LI()

    B = LI()

    bit_length = [0] 

    for i in range(n):

        bit_length += [x + 1 for x in bit_length]

    dp = [[-1] * n for _ in range(1 << n)]

    for i in range(n):

        dp[1 << i][i] = 0

    for mask in range(1 << n):

        dpm = dp[mask]

        c = bit_length[mask]

        for i in range(n):

            if not((1 << i) & mask) or dpm[i] == -1: continue

            w = B[i] if 1 & i == c & 1 else A[i]

            cost = c

            for j in range(n):

                if 1 & (mask >> j):

                    cost -= 1

                else:

                    v = B[j] if 1 & j != c & 1 else A[j]

                    if v >= w:

                        vl = dpm[i] + cost

                        if dp[mask | (1 << j)][j] == -1 or dp[mask | (1 << j)][j] > vl:

                            dp[mask | (1 << j)][j] = vl



    ans = -1

    for i in range(n):

        if dp[-1][i] != -1:

            if ans == -1 or ans > dp[-1][i]:

                ans = dp[-1][i]

    print(ans)



    return





#main

if __name__ == '__main__':

    solve()

import sys

read = sys.stdin.buffer.read

readline = sys.stdin.buffer.readline

readlines = sys.stdin.buffer.readlines



import itertools



N = int(readline())

A = list(map(int,readline().split()))

B = list(map(int,readline().split()))



class BinaryIndexedTree():

    def __init__(self, seq):

        self.size = len(seq)

        self.depth = self.size.bit_length()

        self.build(seq)

        

    def build(self,seq):

        data = seq

        size = self.size

        for i,x in enumerate(data):

            j = i+(i&(-i))

            if j < size:

                data[j] += data[i]

        self.data = data

        

    def __repr__(self):

        return self.data.__repr__()

        

    def get_sum(self,i):

        data = self.data

        s = 0

        while i:

            s += data[i]

            i -= i & -i

        return s

 

    def add(self, i, x):

        data = self.data

        size = self.size

        while i < size:

            data[i] += x

            i += i & -i

    

    def find_kth_element(self,k):

        data = self.data; size = self.size

        x,sx = 0,0

        dx = 1 << (self.depth)

        for i in range(self.depth - 1, -1, -1):

            dx = (1 << i)

            if x + dx >= size:

                continue

            y = x + dx

            sy = sx + data[y]

            if sy < k:

                x,sx = y,sy

        return x + 1



def Inversion(seq):

    # seqは、1,2,...,Nの順列

    N = len(seq)

    bit = BinaryIndexedTree([0] * (N+1))

    inv = N*(N-1)//2

    for x in seq:

        inv -= bit.get_sum(x)

        bit.add(x,1)

    return inv



INF = 10 ** 9

answer = INF

for I in itertools.combinations(list(range(N)),(N+1)//2):

    J = [j for j in range(N) if j not in I]

    ODD = [(B[i] if i&1 else A[i],i) for i in I]

    EV = [(A[i] if i&1 else B[i],i) for i in J]

    ODD.sort()

    EV.sort()

    ind = [0] * N

    seq = [0] * N

    for i in range(0,N,2):

        seq[i], ind[i] = ODD[i//2]

    for i in range(1,N,2):

        seq[i], ind[i] = EV[i//2]

    if not all(x<= y for x,y in zip(seq,seq[1:])):

        continue

    ind = [x+1 for x in ind]

    n = Inversion(ind)

    if answer > n:

        answer = n



if answer == INF:

    answer = -1

print(answer)

#!/usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math

sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt


def LI():
    return list(map(int, input().split()))


def LF():
    return list(map(float, input().split()))


def LI_():
    return list([int(x) - 1 for x in input().split()])


def II():
    return int(eval(input()))


def IF():
    return float(eval(input()))


def LS():
    return list(map(list, input().split()))


def S():
    return list(input().rstrip())


def IR(n):
    return [II() for _ in range(n)]


def LIR(n):
    return [LI() for _ in range(n)]


def FR(n):
    return [IF() for _ in range(n)]


def LFR(n):
    return [LI() for _ in range(n)]


def LIR_(n):
    return [LI_() for _ in range(n)]


def SR(n):
    return [S() for _ in range(n)]


def LSR(n):
    return [LS() for _ in range(n)]


mod = 1000000007
inf = 1e10
"""
URL : https://atcoder.jp/contests/keyence2020/tasks/keyence2020_d
解説AC
きもすぎBit全探索および転倒数
    （転倒数に結びついたら強い
    　隣通しを入れ替えてsortの操作数→バブルソートの操作数→転倒数
    　これの徹底）
AC例1: 最初に考え付いたのはこっち
    maskでどのindexが裏返しになっているかを保持。
    その状況下で生成される表面の数の配列を作成し(これをLとする)ソート。
    iを[0,n)で回して各A[i],B[i]に対して
    maskをもとにAかBが使用されているかを見る。
    Lにおけるその数のindexとiの差の偶奇は奇数B偶数ならA。
    defalutdictかなんかで各Lの数字とそのindexの偶奇の数とそのindexを保持
    indexとiの差の偶奇とdictからLの各indexが元どの番号にいたかを保持。
    あとは元の番号の配列の転倒数を求めればそのmaskにおける操作数が出る
AC例2: 解説はこっち
    maskではどのindexがすでに左側で固定化されたかを保持。
    巡回セールスマンのようにどこを決めて最後に決めたindexは何か
    というDPでいける。（は？）
    というのもmaskだけではそのマスク内の順番はわからないからね。
    欲しいのはその固定化された物の最大の値なので最悪なんかうまくできるかも
    すごすぎ
    こっちを実装します
    700点をACしたいね(2020/3/25/ 20:05)
    Reference: https://atcoder.jp/contests/keyence2020/submissions/9567775 By:yutaka1999
"""
# solve
def solve():
    n = II()
    A = LI()
    B = LI()
    bit_length = [0]
    for i in range(n):
        bit_length += [x + 1 for x in bit_length]
    dp = [[-1] * n for _ in range(1 << n)]
    for i in range(n):
        dp[1 << i][i] = 0
    for mask in range(1 << n):
        dpm = dp[mask]
        c = bit_length[mask]
        for i in range(n):
            if not ((1 << i) & mask) or dpm[i] == -1:
                continue
            w = B[i] if 1 & i == c & 1 else A[i]
            cost = c
            for j in range(n):
                if 1 & (mask >> j):
                    cost -= 1
                else:
                    v = B[j] if 1 & j != c & 1 else A[j]
                    if v >= w:
                        vl = dpm[i] + cost
                        if dp[mask | (1 << j)][j] == -1 or dp[mask | (1 << j)][j] > vl:
                            dp[mask | (1 << j)][j] = vl
    ans = -1
    for i in range(n):
        if dp[-1][i] != -1:
            if ans == -1 or ans > dp[-1][i]:
                ans = dp[-1][i]
    print(ans)
    return


# main
if __name__ == "__main__":
    solve()

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import itertools

N = int(readline())
A = list(map(int, readline().split()))
B = list(map(int, readline().split()))


class BinaryIndexedTree:
    def __init__(self, seq):
        self.size = len(seq)
        self.depth = self.size.bit_length()
        self.build(seq)

    def build(self, seq):
        data = seq
        size = self.size
        for i, x in enumerate(data):
            j = i + (i & (-i))
            if j < size:
                data[j] += data[i]
        self.data = data

    def __repr__(self):
        return self.data.__repr__()

    def get_sum(self, i):
        data = self.data
        s = 0
        while i:
            s += data[i]
            i -= i & -i
        return s

    def add(self, i, x):
        data = self.data
        size = self.size
        while i < size:
            data[i] += x
            i += i & -i

    def find_kth_element(self, k):
        data = self.data
        size = self.size
        x, sx = 0, 0
        dx = 1 << (self.depth)
        for i in range(self.depth - 1, -1, -1):
            dx = 1 << i
            if x + dx >= size:
                continue
            y = x + dx
            sy = sx + data[y]
            if sy < k:
                x, sx = y, sy
        return x + 1


def Inversion(seq):
    # seqは、1,2,...,Nの順列
    N = len(seq)
    bit = BinaryIndexedTree([0] * (N + 1))
    inv = N * (N - 1) // 2
    for x in seq:
        inv -= bit.get_sum(x)
        bit.add(x, 1)
    return inv


INF = 10**9
answer = INF
for I in itertools.combinations(list(range(N)), (N + 1) // 2):
    J = [j for j in range(N) if j not in I]
    ODD = [(B[i] if i & 1 else A[i], i) for i in I]
    EV = [(A[i] if i & 1 else B[i], i) for i in J]
    ODD.sort()
    EV.sort()
    ind = [0] * N
    seq = [0] * N
    for i in range(0, N, 2):
        seq[i], ind[i] = ODD[i // 2]
    for i in range(1, N, 2):
        seq[i], ind[i] = EV[i // 2]
    if not all(x <= y for x, y in zip(seq, seq[1:])):
        continue
    ind = [x + 1 for x in ind]
    n = Inversion(ind)
    if answer > n:
        answer = n
if answer == INF:
    answer = -1
print(answer)

-#!/usr/bin/env python3 -from collections import defaultdict, deque -from heapq import heappush, heappop -from bisect import bisect_left, bisect_right -import sys, random, itertools, math +import sys -sys.setrecursionlimit(10**5) -input = sys.stdin.readline -sqrt = math.sqrt +read = sys.stdin.buffer.read +readline = sys.stdin.buffer.readline +readlines = sys.stdin.buffer.readlines +import itertools + +N = int(readline()) +A = list(map(int, readline().split())) +B = list(map(int, readline().split())) -def LI(): -    return list(map(int, input().split())) +class BinaryIndexedTree: +    def __init__(self, seq): +        self.size = len(seq) +        self.depth = self.size.bit_length() +        self.build(seq) + +    def build(self, seq): +        data = seq +        size = self.size +        for i, x in enumerate(data): +            j = i + (i & (-i)) +            if j < size: +                data[j] += data[i] +        self.data = data + +    def __repr__(self): +        return self.data.__repr__() + +    def get_sum(self, i): +        data = self.data +        s = 0 +        while i: +            s += data[i] +            i -= i & -i +        return s + +    def add(self, i, x): +        data = self.data +        size = self.size +        while i < size: +            data[i] += x +            i += i & -i + +    def find_kth_element(self, k): +        data = self.data +        size = self.size +        x, sx = 0, 0 +        dx = 1 << (self.depth) +        for i in range(self.depth - 1, -1, -1): +            dx = 1 << i +            if x + dx >= size: +                continue +            y = x + dx +            sy = sx + data[y] +            if sy < k: +                x, sx = y, sy +        return x + 1 -def LF(): -    return list(map(float, input().split())) +def Inversion(seq): +    # seqは、1,2,...,Nの順列 +    N = len(seq) +    bit = BinaryIndexedTree([0] * (N + 1)) +    inv = N * (N - 1) // 2 +    for x in seq: +        inv -= bit.get_sum(x) +        bit.add(x, 1) +    return inv -def LI_(): -    return list([int(x) - 1 for x in input().split()]) - - -def II(): -    return int(eval(input())) - - -def IF(): -    return float(eval(input())) - - -def LS(): -    return list(map(list, input().split())) - - -def S(): -    return list(input().rstrip()) - - -def IR(n): -    return [II() for _ in range(n)] - - -def LIR(n): -    return [LI() for _ in range(n)] - - -def FR(n): -    return [IF() for _ in range(n)] - - -def LFR(n): -    return [LI() for _ in range(n)] - - -def LIR_(n): -    return [LI_() for _ in range(n)] - - -def SR(n): -    return [S() for _ in range(n)] - - -def LSR(n): -    return [LS() for _ in range(n)] - - -mod = 1000000007 -inf = 1e10 -""" -URL : https://atcoder.jp/contests/keyence2020/tasks/keyence2020_d -解説AC -きもすぎBit全探索および転倒数 -    （転倒数に結びついたら強い -    　隣通しを入れ替えてsortの操作数→バブルソートの操作数→転倒数 -    　これの徹底） -AC例1: 最初に考え付いたのはこっち -    maskでどのindexが裏返しになっているかを保持。 -    その状況下で生成される表面の数の配列を作成し(これをLとする)ソート。 -    iを[0,n)で回して各A[i],B[i]に対して -    maskをもとにAかBが使用されているかを見る。 -    Lにおけるその数のindexとiの差の偶奇は奇数B偶数ならA。 -    defalutdictかなんかで各Lの数字とそのindexの偶奇の数とそのindexを保持 -    indexとiの差の偶奇とdictからLの各indexが元どの番号にいたかを保持。 -    あとは元の番号の配列の転倒数を求めればそのmaskにおける操作数が出る -AC例2: 解説はこっち -    maskではどのindexがすでに左側で固定化されたかを保持。 -    巡回セールスマンのようにどこを決めて最後に決めたindexは何か -    というDPでいける。（は？） -    というのもmaskだけではそのマスク内の順番はわからないからね。 -    欲しいのはその固定化された物の最大の値なので最悪なんかうまくできるかも -    すごすぎ -    こっちを実装します -    700点をACしたいね(2020/3/25/ 20:05) -    Reference: https://atcoder.jp/contests/keyence2020/submissions/9567775 By:yutaka1999 -""" -# solve -def solve(): -    n = II() -    A = LI() -    B = LI() -    bit_length = [0] -    for i in range(n): -        bit_length += [x + 1 for x in bit_length] -    dp = [[-1] * n for _ in range(1 << n)] -    for i in range(n): -        dp[1 << i][i] = 0 -    for mask in range(1 << n): -        dpm = dp[mask] -        c = bit_length[mask] -        for i in range(n): -            if not ((1 << i) & mask) or dpm[i] == -1: -                continue -            w = B[i] if 1 & i == c & 1 else A[i] -            cost = c -            for j in range(n): -                if 1 & (mask >> j): -                    cost -= 1 -                else: -                    v = B[j] if 1 & j != c & 1 else A[j] -                    if v >= w: -                        vl = dpm[i] + cost -                        if dp[mask | (1 << j)][j] == -1 or dp[mask | (1 << j)][j] > vl: -                            dp[mask | (1 << j)][j] = vl -    ans = -1 -    for i in range(n): -        if dp[-1][i] != -1: -            if ans == -1 or ans > dp[-1][i]: -                ans = dp[-1][i] -    print(ans) -    return - - -# main -if __name__ == "__main__": -    solve() +INF = 10**9 +answer = INF +for I in itertools.combinations(list(range(N)), (N + 1) // 2): +    J = [j for j in range(N) if j not in I] +    ODD = [(B[i] if i & 1 else A[i], i) for i in I] +    EV = [(A[i] if i & 1 else B[i], i) for i in J] +    ODD.sort() +    EV.sort() +    ind = [0] * N +    seq = [0] * N +    for i in range(0, N, 2): +        seq[i], ind[i] = ODD[i // 2] +    for i in range(1, N, 2): +        seq[i], ind[i] = EV[i // 2] +    if not all(x <= y for x, y in zip(seq, seq[1:])): +        continue +    ind = [x + 1 for x in ind] +    n = Inversion(ind) +    if answer > n: +        answer = n +if answer == INF: +    answer = -1 +print(answer)