CodeEff/ECCO huggingface dataset:
# Original solution
#n = 5
#C = list(map(int,"1 2 3 4 5".split()))
#line = ["1 2", "2 3", "3 4", "3 5"]
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline

n = int(eval(input()))
C = list(map(int,input().split()))
 
ci = [set() for _ in range(n)]
for i,c in enumerate(C):
    ci[c-1].add(i)

path = [set() for _ in range(n)]
 
#line = ["1 2", "2 3"]
    
for i in range(n-1):
    a,b = list(map(int,input().split()))
    #a,b = map(int,line[i].split())
    a -= 1
    b -= 1
    path[a].add(b)
    path[b].add(a)
    
ans = [n*(n+1)//2]*n
size = [0]*n
cparent = [[] for _ in range(n)]
reached = [False]*n
root_size = [n]*n

def dfs (p):
    c = C[p] - 1
    cparent[c].append(p)
    s = 1
    for nxt in path[p]:
        #print (nxt)
        size[p] = 0
        if reached[nxt]:
            continue
        reached[nxt] = True
        ret = dfs(nxt)
        s += ret
        size[p] +=ret
        ans[c] -= size[p] * (size[p] + 1)//2
    cparent[c].pop()
    if cparent[c]:
        size[cparent[c][-1]] -=s
    else:
        root_size[c] -=s    
    return s

reached[0] = True
dfs (0)

for i in range(n):
    print((ans[i]-root_size[i]*(root_size[i]+1)//2))


# Optimized solution
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline

n = int(eval(input()))
C = list(map(int,input().split()))

path = [set() for _ in range(n)]

for i in range(n-1):
    a,b = list(map(int,input().split()))
    a -= 1
    b -= 1
    path[a].add(b)
    path[b].add(a)
    
ans = [n*(n+1)//2]*n
size = [0]*n
cparent = [[] for _ in range(n)]
reached = [False]*n
root_size = [n]*n

def dfs (p):
    c = C[p] - 1
    cparent[c].append(p)
    s = 1
    for nxt in path[p]:
        #print (nxt)
        
        if reached[nxt]:
            continue
        size[p] = 0
        reached[nxt] = True
        ret = dfs(nxt)
        s += ret
        size[p] +=ret
        ans[c] -= size[p] * (size[p] + 1)//2
    cparent[c].pop()
    if cparent[c]:
        size[cparent[c][-1]] -=s
    else:
        root_size[c] -=s    
    return s

reached[0] = True
dfs (0)

for i in range(n):
    print((ans[i]-root_size[i]*(root_size[i]+1)//2))
# Original solution
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
from collections import defaultdict
INF = float("inf")
MOD = 10**9+7


class Graph(object):
    def __init__(self, N):
        self.N = N
        self.E = defaultdict(list)

    def add_edge(self, f, t, w=1):
        self.E[f].append((t, w))
        self.E[t].append((f, w))


N = int(eval(input()))
c = [x-1 for x in map(int, input().split())]
A = [None]*(N-1)
B = [None]*(N-1)
for i in range(N-1):
    A[i], B[i] = list(map(int, input().split()))

g = Graph(N)
for a, b in zip(A, B):
    g.add_edge(a-1, b-1)

# k=1, 2, ..., Nに対して
# 色kが塗られている頂点を一度以上通るような単純パスの数を求める
# 全パスの個数 - 色kが塗られている頂点を一度も通らない単純パスの数
# 全パスの個数はN*(N+1)/2

# グラフを色kのノードで分割して、部分グラフ内での単純パスの総数を求めれば良い
# 各ノードに状態として辞書をもたせる。
# 辞書は色iを通らずに到達可能な頂点の数を持つ。

# 回答用
ans = [0]*N


def f(curr, par=-1):
    # 再帰関数
    # curr: 現在の節点
    # par : 親節点の番号
    ret = defaultdict(int)
    for dest, w in g.E[curr]:
        if dest == par:
            continue
        child = f(dest, curr)

        # 自身の色と同じ場合、子の頂点の数から加算
        n = child[c[curr]]
        ans[c[curr]] += n*(n+1)//2

        # マージ
        if len(ret) < len(child):
            child, ret = ret, child
        for key in child:
            ret[key] += child[key]
        ret[c[curr]] = 0

    for color in range(N):
        if color != c[curr]:
            ret[color] += 1
    return ret


ret = f(0)
for color in range(N):
    if color != c[0]:
        n = ret[color]
        ans[color] += n*(n+1)//2

tot = N*(N+1)//2
for a in ans:
    print((tot-a))


# Optimized solution
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
from collections import defaultdict
INF = float("inf")
MOD = 10**9+7


class Graph(object):
    def __init__(self, N):
        self.N = N
        self.E = defaultdict(list)

    def add_edge(self, f, t, w=1):
        self.E[f].append((t, w))
        self.E[t].append((f, w))


N = int(eval(input()))
c = [x-1 for x in map(int, input().split())]
A = [None]*(N-1)
B = [None]*(N-1)
for i in range(N-1):
    A[i], B[i] = list(map(int, input().split()))

g = Graph(N)
for a, b in zip(A, B):
    g.add_edge(a-1, b-1)

# k=1, 2, ..., Nに対して
# 色kが塗られている頂点を一度以上通るような単純パスの数を求める
# 全パスの個数 - 色kが塗られている頂点を一度も通らない単純パスの数
# 全パスの個数はN*(N+1)/2

# グラフを色kのノードで分割して、部分グラフ内での単純パスの総数を求めれば良い
# 各ノードに状態として辞書をもたせる。
# x辞書は色iを通らずに到達可能な頂点の数を持つ。
# o辞書は色iを通らずに到達不可能な頂点の数を持つ。

# 回答用
ans = [0]*N


def f(curr, par=-1):
    # 再帰関数
    # curr: 現在の節点
    # par : 親節点の番号
    ret = defaultdict(int)
    size = 1
    for dest, w in g.E[curr]:
        if dest == par:
            continue
        sz, child = f(dest, curr)
        size += sz

        # 自身の色と同じ場合、子の頂点の数から加算
        n = sz-child[c[curr]]
        ans[c[curr]] += n*(n+1)//2

        # マージ
        if len(ret) < len(child):
            child, ret = ret, child
        for key in child:
            ret[key] += child[key]

    ret[c[curr]] = size
    return size, ret


sz, ret = f(0)
for color in range(N):
    if color != c[0]:
        n = sz-ret[color]
        ans[color] += n*(n+1)//2

tot = N*(N+1)//2
for a in ans:
    print((tot-a))
# Original solution
A, B, X = list(map(int, input().split()))

if A > X:
    print("NO")
elif X - A <= B:
    print("YES")
else:
    print("NO")

# Optimized solution
A, B, X = list(map(int, input().split()))
print(("YES" if 0 <= X - A <= B else "NO"))
# Original solution
#                         author:  kagemeka 
#                         created: 2019-11-07 11:52:43(JST)
import sys
# import collections
# import math
# import string
# import bisect
# import re
# import itertools
# import statistics
# import functools
# import operator

def main():
    a, b, x = (int(i) for i in sys.stdin.readline().split())
    print(('YES' if x >= a and b >= x - a else 'NO')) 


if __name__ == "__main__":
    # execute only if run as a script
    main()


# Optimized solution
import sys

a, b, x = list(map(int, sys.stdin.readline().split()))

def main():
    return 'YES' if a <= x <= a + b else 'NO'

if __name__ == '__main__':
    ans = main()
    print(ans)
# Original solution
a,b,x = list(map(int,input().split()))
 
if a <= x and a + b >= x:
  print('YES')
else:
	print('NO')

# Optimized solution
a,b,x = list(map(int,input().split()))

if a <= x <= a+b:
    print("YES")
else:
    print("NO")
# Original solution
a,b,x = map(int,input().split())
print("YES") if a<=x<=a+b else print("NO")


# Optimized solution
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
    a, b, x = list(map(int, input().split()))
    print(("YES" if a <= x <= a + b else "NO"))
resolve()
# Original solution
A,B,X = list(map(int,input().split()))
if A>X:
    print("NO")
if A<=X:
    if (A +B)<X:
        print("NO")
    else:
        print("YES")


# Optimized solution
a,b,x = list(map(int,input().split()))
if a > x:
  print("NO")
elif a + b < x:
  print("NO")
else:
  print("YES")
# Original solution
A,B,X=list(map(int,input().split()))
print(("YES" if A<=X and X<=A+B else "NO"))

# Optimized solution
A,B,X=list(map(int,input().split()))
print(("YES" if A<=X<=A+B else "NO"))
# Original solution
a,b,x = list(map(int,input().split()))
print((["NO","YES"][(a+b>=x)*(x>=a)]))

# Optimized solution
a,b,x = list(map(int,input().split()))
print((["NO","YES"][a+b>=x>=a]))
# Original solution
a, b, x= list(map(int, input().split()))

if a > x:
    print("NO")
elif a+b >= x:
    print("YES")
else:
    print("NO")

# Optimized solution
import math
import itertools
#n = int(input())
#n, d = list(input().split())
A, B, X= list(map(int, input().split()))

if A == X or (A < X and A+B > X) :
    print("YES")
else:
    print("NO")
# Original solution
A, B, X = list(map(int, input().split()))
print(('YES' if A + B >= X and X >= A else 'NO'))

# Optimized solution
A, B, X = list(map(int, input().split()))
print(('YES' if A <= X <= A + B else 'NO'))
# Original solution
def main():
    t = list(map(int, input().split()))
    for i in range(t[1]):
        tmp = i + t[0]
        if tmp == t[2]:
            print('YES')
            exit()
    print('NO')

if __name__ == '__main__':
    main()


# Optimized solution

url = "https://atcoder.jp//contests/abc094/tasks/abc094_a"

def main():
    t = list(map(int, input().split()))
    for i in range(t[1]):
        tmp = i + t[0]
        if tmp == t[2]:
            print('YES')
            exit()
    print('NO')

if __name__ == '__main__':
    main()
# Original solution
# Aは猫, Bはどっちかわからん
A, B, X = list(map(int, input().split()))

if X - A < 0:
    print('NO')
elif X - A > B:
    print('NO')
else:
    print('YES')


# Optimized solution
A, B, X = list(map(int, input().split()))

print(('NO' if X - A < 0 or X - A > B else 'YES'))
# Original solution
a, b, x = list(map(int, input().split()))
if x >= a and x - a <= b:
    print('YES')
else:
    print('NO')

# Optimized solution
a, b, x = list(map(int, input().split()))
print(('YES' if a <= x <= (a + b) else 'NO'))
# Original solution

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

INF = 1 << 29

"""
・dp[bit][s]
ビットに1が立っているカードはソートされて左から並んでいる。
そのとき最後の値をsにするのに必要な最小操作回数


"""
# 1 <= A,B <= 50, bitの立ち方が 0...0 ~ 1...1 の2**N
dp = [[INF for _ in range(50 + 1)] for _ in range((1 << N))]
# 0枚選んでいて右端が0は何もしてないのでコスト0
dp[0][0] = 0

for bit in range(1 << N):
    # 現在見ているbit列にいくつ1が立っているか＝カードを何枚既に選んで並べているか
    num_used = bin(bit).count("1")
    
    # bitで１が立っていない＝まだ使われていないカードがどこにあるか
    idx = num_used
    remaining = []
    for i in range(N):
        if not (bit & (1 << i)):
            # 一つ目が初期位置、二つ目は、bitで１が立っているやつらを左に寄せた時にどの位置にいるか
            remaining.append((i, idx))
            idx += 1

    for s in range(51):
        # bitの集合かつ、その右端にsの状態が作れないならスキップ
        if dp[bit][s] >= INF:
            continue

        for ini, curr in remaining:
            """
            ini  : initial position
            curr : current position
            現時点でnum_used-1のインデックスまでカードがソートされて並んでいる
            最初iniの位置にあったカードを最後尾に並べることを考える
            """
            num = A[ini] if abs(ini - num_used) % 2 == 0 else B[ini]

            """
            numが並んでるカードの最後尾より大きければ最後尾につける
            """
            if num >= s:
                # 元の集合と、iniの位置だけ１が立ってるものの論理和で、追加した状態を表す
                # その場合の最小コストは、既に求まっているもの or 新たにnum_usedの位置にiniのカードをあてたとき　の小さいほう
                dp[bit | (1 << ini)][num] = min(dp[bit | (1 << ini)][num], dp[bit][s] + abs(num_used - curr))



# 全てのbitに1が立っている（全て並べ切った）時の最小コストが答え
ans = min(dp[-1][s] for s in range(51))

print((ans if ans < INF else -1))


# Optimized solution



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

INF = 1 << 20

# bitで１が立っているidxのカードがソートされて左詰めで並んでいるとき、その右端（＝最大のカード）がsとなる最小コスト
dp = [[INF for _ in range(51)] for _ in range(1 << N)]
dp[0][0] = 0

for bit in range(1 << N):

    # 既に並べてあるカードの枚数
    num_used = bin(bit).count("1")

    curr = num_used
    remaining = []
    for i in range(N):
        # bitのi番目に１が立っていない（＝まだ選ばれていない）とき
        if not(bit & (1 << i)):
            remaining.append((i, curr))
            curr += 1

    for s in range(51):
        # あるカードの並べ方について、右端をsにできないならスキップ
        if dp[bit][s] >= INF:
            continue

        for ini, curr in remaining:
            # iniの場所に最初いたカードを、num_usedの位置に持ってくるので、その偶奇によって表か裏かがわかる
            num = A[ini] if abs(num_used - ini) % 2 == 0 else B[ini]

            # numがsより小さい場合、整列したカードの最後尾につけられない
            if num >= s:
                # ある選び方で並んでいるカード群に、ini番目のカードを新たに最後尾に追加したとき、最後尾がnumとなる最小コスト
                dp[bit | (1 << ini)][num] = min(dp[bit | (1 << ini)][num], dp[bit][s] + abs(num_used - curr))

ans = INF
for i in range(51):
    ans = min(ans, dp[-1][i])

print((ans if ans < INF else -1))
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))

INF = 1 << 29
dp = [[INF] * 55 for _ in range((1 << N) + 1)]
dp[0][0] = 0

for bit in range(1 << N):
    con = 0
    for i in range(N):
        if bit & (1 << i):
            con += 1
            
    ords = []
    iters = con
    for i in range(N):
        if not (bit & (1 << i)):
            ords.append([i, iters])
            iters += 1

    for s in range(51):
        if dp[bit][s] >= INF:
            continue

        for p in ords:
            # p[0]: 元々のaのindex, p[1]: dp[bit][s]の状態でのindex
            ns = -1
            if abs(p[0] - con) % 2 == 0:
                ns = A[p[0]]
            else:
                ns = B[p[0]]

            if ns >= s:
                dp[bit|(1 << p[0])][ns] = min(dp[bit|(1 << p[0])][ns],
                                              dp[bit][s] + abs(p[1] - con))
                    
ans = INF
for s in range(51):
    ans = min(ans, dp[(1 << N) - 1][s])
if ans < INF:
    print(ans)
else:
    print((-1))


# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))

INF = 1 << 20
dp = [[INF] * 51 for _ in range(1 << N)]
dp[0][0] = 0

for bit in range(1 << N):
    # 左詰めソートされている数
    con = bin(bit).count("1")

    # bitに含まれないカード
    ords = []
    iters = con
    for i in range(N):
        if not (bit & (1 << i)):
            ords.append([i, iters])
            iters += 1

    for s in range(51):
        if dp[bit][s] >= INF:
            continue

        for p in ords:
            # p[0]: 元々のindex, p[1]: dp[bit][s]の状態でのindex
            # con: bitの中身の数（既に詰まっているindexの最後尾）
            # |i-j|が偶数ならばA[i], 奇数ならばB[i]
            ns = A[p[0]] if abs(p[0] - con) % 2 == 0 else B[p[0]]

            # bitの中身がcon枚なので，bitに含まれないものはcon+1から順に詰める
            # 新しく詰める値nsが，既に詰まっている値の最大値sよりも大きい場合，
            # その値を後ろに詰める．
            if ns >= s:
                # 詰める時の最小の操作回数をdpで調べる．
                dp[bit|(1 << p[0])][ns] = min(dp[bit|(1 << p[0])][ns],
                                              dp[bit][s] + abs(con - p[1]))

ans = min(dp[-1][s] for s in range(51))
print((ans if ans < INF else -1))
# Original solution
from collections import defaultdict
from operator import itemgetter
N = int(eval(input()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))

ans = 1000
for n in range(2**N):
    n = bin(n)[2:]
    if n.count('1')%2!=0:
        continue
    n = '0'*(N-len(n))+n
    l = []
    for i in range(N):
        if n[i]=='0':
            l.append([A[i],i])
        else:
            l.append([B[i],i+1])
    inversion = 0
    for i in range(N):
        if inversion>=ans:
            break
        for j in range(i+1,N):
            if l[i][0]>l[j][0]:
                inversion += 1
    if inversion>=ans:
        continue
    l.sort(key=itemgetter(0,1))
    d = defaultdict(list)
    for i in range(N):
        v,j = l[i]
        if (i-j)%2==1:
            d[v].append(i)
    possible = True
    for v in d:
        if len(d[v])%2==1:
            possible = False
        else:
            for i in range(len(d[v])//2):
                if (d[v][2*i+1]-d[v][2*i])%2==1:
                    inversion += d[v][2*i+1]-d[v][2*i]
                else:
                    possible = False
                    break
        if not possible:
            break
    if possible:
        ans = min(ans,inversion)

if ans == 1000:
    ans = -1
print(ans)

# Optimized solution
from collections import defaultdict
from operator import itemgetter
N = int(eval(input()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))

ans = 1000
for n in range(2**N):
    n = bin(n)[2:]
    if n.count('1')%2!=0:
        continue
    n = '0'*(N-len(n))+n
    l = []
    for i in range(N):
        if n[i]=='0':
            l.append([A[i],i])
        else:
            l.append([B[i],i+1])
    inversion = 0
    for i in range(N):
        if inversion>=ans:
            break
        for j in range(i+1,N):
            if l[i][0]>l[j][0]:
                inversion += 1
    if inversion>=ans:
        continue
    l.sort(key=itemgetter(0))
    d = defaultdict(list)
    for i in range(N):
        v,j = l[i]
        if (i-j)%2==1:
            d[v].append(i)
    possible = True
    for v in d:
        if len(d[v])%2==1:
            possible = False
        else:
            for i in range(len(d[v])//2):
                if (d[v][2*i+1]-d[v][2*i])%2==1:
                    inversion += d[v][2*i+1]-d[v][2*i]
                else:
                    possible = False
                    break
        if not possible:
            break
    if possible:
        ans = min(ans,inversion)

if ans == 1000:
    ans = -1
print(ans)
# Original solution
def tentousu(a):
  ans=0
  for i in range(len(a)):
    for j in range(i+1,len(a)):
      if a[i]>a[j]:ans+=1
  return ans
n=int(eval(input()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
for i in range(1,n,2):a[i],b[i]=b[i],a[i]
ans=inf=float('inf')
for i in range(2**n):
  s=bin(i)[2:].zfill(n)
  if s.count("0")!=n//2:continue
  ac=[]
  bc=[]
  for j in range(n):
    if s[j]=="1":ac.append((a[j],j))
    else:bc.append((b[j],j))
  ac.sort()
  bc.sort()
  x=[]
  for j in range(n):
    if j%2:x.append(bc[j//2])
    else:x.append(ac[j//2])
  f=False
  for j in range(1,n):
    if x[j-1][0]>x[j][0]:f=True
  if f:continue
  m=[]
  for j in range(n):m.append(x[j][1])
  ans=min(ans,tentousu(m))
if ans==inf:ans=-1
print(ans)

# Optimized solution
def tentousu(a):
  ans=0
  for i in range(len(a)):
    for j in range(i+1,len(a)):
      if a[i]>a[j]:ans+=1
  return ans
n=int(eval(input()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
for i in range(1,n,2):a[i],b[i]=b[i],a[i]
ans=inf=float('inf')
for i in range(2**n):
  s=bin(i)[2:].zfill(n)
  if s.count("0")!=n//2:continue
  if s.count("1")!=n//2 and s.count("1")!=n//2+1:continue
  ac=[]
  bc=[]
  for j in range(n):
    if s[j]=="1":ac.append((a[j],j))
    else:bc.append((b[j],j))
  ac.sort()
  bc.sort()
  x=[]
  for j in range(n):
    if j%2:x.append(bc[j//2])
    else:x.append(ac[j//2])
  f=False
  for j in range(1,n):
    if x[j-1][0]>x[j][0]:f=True
  if f:continue
  m=[]
  for j in range(n):m.append(x[j][1])
  ans=min(ans,tentousu(m))
if ans==inf:ans=-1
print(ans)
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
ab=lambda i,j:a[i] if abs(i-j)%2==0 else b[i]
inf=10**9
dp=[n*[inf]for _ in range(2**n)]
dp[0][0]=0
for i in range(n):dp[2**i][i]=i
for bit in range(1,2**n):
  m=[0]*n
  ii=0
  for i in range(n):
    if bit&2**i:
      m[i]=ii
      ii+=1
  bit_count=ii
  for i in range(n):
    if bit&2**i==0:
      m[i]=ii
      ii+=1
  for i in range(n):
    if bit&2**i:continue
    ci=ab(i,bit_count)
    for j in range(n):
      if bit&2**j==0:continue
      cj=ab(j,bit_count-1)
      if cj>ci:continue
      dp[bit|2**i][i]=min(dp[bit|2**i][i],dp[bit][j]+m[i]-bit_count)
ans=inf
for i in range(n):ans=min(ans,dp[-1][i])
if ans==inf:ans=-1
print(ans)

# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
ab=lambda i,j:a[i] if abs(i-j)%2==0 else b[i]
inf=10**9
dp=[n*[inf]for _ in range(1<<n)]
dp[0][0]=0
for i in range(n):dp[1<<i][i]=i
for bit in range(1,1<<n):
  m=[0]*n
  ii=0
  for i in range(n):
    if bit&1<<i:
      m[i]=ii
      ii+=1
  bit_count=ii
  for i in range(n):
    if bit&1<<i==0:
      m[i]=ii
      ii+=1
  for i in range(n):
    if bit&1<<i:continue
    ci=ab(i,bit_count)
    for j in range(n):
      if bit&1<<j==0:continue
      cj=ab(j,bit_count-1)
      if cj>ci:continue
      dp[bit|(1<<i)][i]=min(dp[bit|(1<<i)][i],dp[bit][j]+m[i]-bit_count)
ans=inf
for i in range(n):ans=min(ans,dp[-1][i])
if ans==inf:ans=-1
print(ans)
# Original solution
def main():
  N = int(eval(input()))
  A = list(map(int,input().split()))
  B = list(map(int,input().split()))
  # M:カードの数字の最大値+1
  M = max(max(A),max(B))+1
  INF=float('inf')
  # dp[mask][a]:maskのカードが操作済で、そのうち右端のカードの数字がaであるときの操作回数の最小値
  dp = [[INF for _ in range(M)] for _ in range(1<<N)]
  dp[0][0] = 0
  
  for i in range(1<<N):
    # idx:操作済カードの枚数
    idx = 0
    for k in range(N):
      #k番目のカードが操作済みかどうか判定する。iでk番目にフラグがたってたら、操作済みとする。
      if (i>>k)&1 == 1:
        idx += 1
    for j in range(M):
      if dp[i][j] >= INF:
        continue
      for k in range(N):
        # k:右端の操作済カードの次に来るカード
        # kがすでに操作済の場合はcontinueする
        
        # kが何回操作されるかによってkの数字が表の数字になるか裏の数字になるかが決まる
        if abs(k-idx)%2 == 0:
          c = A[k]
        else:
          c = B[k]
  
        # kの数字広義単調増加にならない場合はcontinue
        if j > c:
          continue
        
        # t:kを右端の操作済カードの次に並べるための操作回数
        # それは、初期配置でkより左にあってまだ操作済でないカードの枚数と一致する
        t = 0
        for l in range(k):
          if (i>>l)&1 == 0:
            t += 1
        #print(i,k,idx,c,dp[i|(1<<k)][c],t)
        dp[i|(1<<k)][c] = min(dp[i|(1<<k)][c],dp[i][j]+t)
  
  ans = INF
  for i in range(M):
    ans = min(dp[(1<<N)-1][i],ans)
  print((ans if ans < INF else -1))

if __name__ == '__main__':
  main()

# Optimized solution
def main():
  N = int(eval(input()))
  A = list(map(int,input().split()))
  B = list(map(int,input().split()))
  # M:カードの数字の最大値+1
  M = max(max(A),max(B))+1
  INF=float('inf')
  # dp[mask][a]:maskのカードが操作済で、そのうち右端のカードの数字がaであるときの操作回数の最小値
  dp = [[INF for _ in range(M)] for _ in range(1<<N)]
  dp[0][0] = 0
  
  for i in range(1<<N):
    # idx:操作済カードの枚数
    idx = 0
    for k in range(N):
      #k番目のカードが操作済みかどうか判定する。iでk番目にフラグがたってたら、操作済みとする。
      if (i>>k)&1 == 1:
        idx += 1
    for j in range(M):
      if dp[i][j] >= INF:
        continue
      for k in range(N):
        # k:右端の操作済カードの次に来るカード
        # kがすでに操作済の場合はcontinueする
        if (i>>k)&1:
          continue
        
        # kが何回操作されるかによってkの数字が表の数字になるか裏の数字になるかが決まる
        if abs(k-idx)%2 == 0:
          c = A[k]
        else:
          c = B[k]
  
        # kの数字広義単調増加にならない場合はcontinue
        if j > c:
          continue
        
        # t:kを右端の操作済カードの次に並べるための操作回数
        # それは、初期配置でkより左にあってまだ操作済でないカードの枚数と一致する
        t = 0
        for l in range(k):
          if (i>>l)&1 == 0:
            t += 1
        #print(i,k,idx,c,dp[i|(1<<k)][c],t)
        dp[i|(1<<k)][c] = min(dp[i|(1<<k)][c],dp[i][j]+t)
  
  ans = INF
  for i in range(M):
    ans = min(dp[(1<<N)-1][i],ans)
  print((ans if ans < INF else -1))

if __name__ == '__main__':
  main()