// Arup Guha
// 2/11/2017
// Min Cross
// Fixed on 2/16/2017 - I just forgot to rotate the top side of the road...that was dumb.

import java.util.*;
import java.io.*;

public class mincross {

	public static int n;

	public static void main(String[] args) throws Exception {

		// Open file.
		BufferedReader stdin = new BufferedReader(new FileReader("mincross.in"));
		n = Integer.parseInt(stdin.readLine().trim());
		int[] map = new int[n];
		int[] orig1 = new int[n];

		// Store these in reverse.
		for (int i=0; i<n; i++) {
			orig1[i] = Integer.parseInt(stdin.readLine().trim());
			map[orig1[i]-1] = i+1;
		}

		// Stores permutation 1 based, since my bit is 1 based.
		int[] perm = new int[n];
		int[] orig2 = new int[n];
		for (int i=0; i<n; i++) {
			orig2[i] = Integer.parseInt(stdin.readLine().trim());
			perm[i] = map[orig2[i]-1];
		}

		// Best answer by rotating bottom.
		long moveBottom = solve(perm);

		// Now, redo this in opposite order.
		for (int i=0; i<n; i++)
			map[orig2[i]-1] = i+1;
		for (int i=0; i<n; i++)
			perm[i] = map[orig1[i]-1];

		// Best answer by rotating top.
		long moveTop = solve(perm);

		// Take the better answer.
		long best = Math.min(moveBottom, moveTop);

		// Ta da!
		PrintWriter out = new PrintWriter(new FileWriter("mincross.out"));
		out.println(best);
		out.close();
		stdin.close();
	}

	public static long solve(int[] perm) {

		bit myBit = new bit(n);
		long cur = 0;

		// Run from left to right using BIT computing # taller on left of i.
		for (int i=0; i<n; i++) {
			cur += myBit.above(perm[i]);
			myBit.add(perm[i], 1L);
		}

		long best = cur;
		for (int i=n-1; i>0; i--) {
			cur = cur + 2*perm[i] - n - 1;
			best = Math.min(best, cur);
		}

		return best;
	}
}

class bit {

	public long[] cumfreq;

	// Do indexes 1 to n.
	public bit(int n) {

		int size = 1;
		while (size < n) size <<= 1;
		n = size;

		cumfreq = new long[n+1];
	}

	// Uses 1 based indexing.
	public void add(int index, long value) {
		while (index < cumfreq.length) {
			cumfreq[index] += value;
			index += Integer.lowestOneBit(index);
		}
	}

	// Returns the sum of everything upto index.
	public long sum(int index) {
		long ans = 0;
		while (index > 0) {
			ans += cumfreq[index];
			index -= (Integer.lowestOneBit(index));
		}
		return ans;
	}

	// Use 1 based indexing.
	public long sum(int low, int high) {
		return sum(high) - sum(low-1);
	}

	// Return the total number of items in the BIT.
	public long all() {
		return sum(cumfreq.length-1);
	}

	// Return the total number of items in the BIT at or above index.
	public long above(int index) {
		return all() - sum(index);
	}
}