output_description: 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.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      A_1 A_2 ... A_N
      B_1 B_2 ... B_N
attempt: import sys
  
  input = lambda: sys.stdin.readline().rstrip()
  sys.setrecursionlimit(max(1000, 10**9))
  write = lambda x: sys.stdout.write(x + "\n")
  
  
  n = int(input())
  a = list(map(int, input().split()))
  b = list(map(int, input().split()))
  nums = [None] * n
  
  # def groupby(l):
  #     """l : list of tuple
  #     tuple[0]で分割する
  #     """
  #     if len(l)==0:
  #         pass
  #     else:
  
  #         yield
  
  
  def pp(func):
      def wrapped(*args, **keys):
          print(args, keys)
          val = func(*args, **keys)
          print(val)
          return val
  
      return wrapped
  
  
  # @pp
  def sub(fr, to, bb):
      # frをtoのいずれかに対応付ける
      elist = []
      olist = []
      for ff, bbb in zip(fr, bb):
          if (ff + bbb) % 2:
              olist.append(ff)
          else:
              elist.append(ff)
  
      elist2 = []
      olist2 = []
      for item in to:
          if item % 2:
              olist2.append(item)
          else:
              elist2.append(item)
      if len(olist2) == len(olist) and len(elist2) == len(elist):
          olist.sort()
          elist.sort()
          return sum(abs(o1 - o2) for o1, o2 in zip(olist, olist2)) + sum(
              abs(e1 - e2) for e1, e2 in zip(elist, elist2)
          )
      else:
          return None
  
  
  #     if sum((ff-tt-bbb)%2 for ff,tt,bbb in zip(fr, to, bb)):
  #         return None
  
  
  best = 10**9
  for bit in range(1 << n):
      for i in range(n):
          val = b[i] if bit >> i & 1 else a[i]
          nums[i] = (val, i, bit >> i & 1)
      nums.sort()
      prev, fr, bb = nums[0]
      to = [0]
      fr = [fr]
      bb = [bb]
      valid = True
      ans = 0
      for i in range(1, n):
          cv, cfr, cbb = nums[i]
          if prev != cv:
              res = sub(fr, to, bb)
              if res is None:
                  valid = False
                  break
              ans += res
              prev, fr, bb = cv, [cfr], [cbb]
              to = [i]
          else:
              fr.append(cfr)
              to.append(i)
              bb.append(cbb)
      else:
          res = sub(fr, to, bb)
          if res is None:
              valid = False
          else:
              ans += res
      if valid:
          best = min(best, ans)
  #         print(nums, ans)
  if best == 10**9:
      print(-1)
  else:
      print(best // 2)
  
problem_description: 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.
samples: [{"input": "3\n    3 4 3\n    3 2 3", "output": "1\n    \n\nBy doing the operation once with i = 1, we have a sequence [2, 3, 3] facing\nup, which is non-decreasing.\n\n* * *"}, {"input": "2\n    2 1\n    1 2", "output": "-1\n    \n\nAfter any number of operations, we have the sequence [2, 1] facing up, which\nis not non-decreasing.\n\n* * *"}, {"input": "4\n    1 2 3 4\n    5 6 7 8", "output": "0\n    \n\nNo operation may be required.\n\n* * *"}, {"input": "5\n    28 15 22 43 31\n    20 22 43 33 32", "output": "-1\n    \n\n* * *"}, {"input": "5\n    4 46 6 38 43\n    33 15 18 27 37", "output": "3"}]