/*
TASK:round
LANG:C++
*/

#include <stdio.h>
#include <vector>
using namespace std;


const int UNKNOWN = -2;
const int N = 2 * 1024;

int L[N], R[N];
int f[N][N];
int i, j, n;

struct ITree{

 	vector<int> tree[20];
  int level;
  
	void Init(int size){
  	int temp_size = 1;
    i=0;
    while(temp_size < 2*size){
   		tree[i].resize(temp_size);
      temp_size *= 2;
      i++;
    }
    level = i-1;
  }

  void Push(int value){
  	tree[level][value]++;
    int temp_level = level;
    do{
    	temp_level--;
      value /= 2;
    	tree[temp_level][value]++;
    }while(temp_level);
  }

  void Pop(int value){
	  tree[level][value]--;
    int temp_level = level;
    do{
    	temp_level--;
      value /= 2;
    	tree[temp_level][value]--;
    }while(temp_level);

  }

  int CountLess(int value){
  	int ret = 0;
    int temp_level = level;
    do{
    	if(value % 2)
      	ret += tree[temp_level][value-1];
      temp_level--;
      value /= 2;
    }while(temp_level);
    return ret;
  }

  int Size(){
  	return tree[0][0];
  }

  ~ITree(){
  	for(int i=0; i<20; i++)
    	tree[i].clear();
  }
  
};

ITree heap;

void Input(){

//	freopen("round.in", "rt", stdin);

	scanf("%d", &n);
	for(i=n; i>=1; i--)
     scanf("%d", &L[i]);
	for(i=n; i>=1; i--)
     scanf("%d", &R[i]);
}


int min(int p, int q){
	return p < q ? p : q;
}

int abs(int p){
	return p > 0 ? p : -p;
}

int CountLeftEnter(int value){
	int temp = heap.CountLess(value);
  int size = heap.Size();

  if(min(temp, size-(temp+1)) < 0)
  	printf("ERROORRR LEFFTTT\n");
	return min(temp, size - (temp+1));
}

int CountRightEnter(int value){

	int temp = heap.CountLess(value);
  int mid = heap.CountLess(n+1);
  int size = heap.Size();//CountLess(2*n+1);

 	//return min(abs(mid - temp), heap.Size() - abs(mid + temp + 1));

  if(value <= n){
  	if(min(mid - (temp+1), size - mid + temp) < 0)
    	printf("ERR RIGHT 1\n");
  	return min(mid - (temp+1), size - mid + temp);
  }
  else{
  	if(temp < mid)
    	printf("-----\n");
  	if(min(temp - mid, size - (temp+1) + mid) < 0)
    	printf("ERR RIGHT 2\n");
  	return min(temp - mid, size - (temp+1) + mid);
  }

}

int F(int left, int right){

	if(f[left][right] != UNKNOWN)
  	return f[left][right];

  int ret1 = 1023456789;
  int ret2 = 1023456789;;
  
  if(right){
  	heap.Push(R[right]);
  	ret1 = F(left, right-1) + CountRightEnter(R[right]);
    heap.Pop(R[right]);
  }
  if(left){
  	heap.Push(L[left]);
  	ret2 = F(left-1, right) + CountLeftEnter(L[left]);
    heap.Pop(L[left]);
  }

//	F(left, right-1);
//	F(left-1, right);
	f[left][right] = min(ret1, ret2);
  return f[left][right];
}

void DebugTree(){
	ITree a;
  a.Init(32);
  a.Push(4);
  a.Push(10);
  a.Push(5);
  printf("%d\n", a.CountLess(6));
  a.Pop(5);
  printf("%d\n", a.CountLess(6));
  
}


int main(){
	Input();

  heap.Init(4*n);
  
  for(i=0; i<=n; i++)
  	for(j=0; j<=n; j++)
    	f[i][j] = UNKNOWN;
	f[0][0] = 0;
//  DebugTree();

  printf("%d\n", F(n, n));

	return 0;
}
