#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

const int MAXN = (int) 3e3 + 5;
const ll MOD = 494406068045569;
const int P = 3491;

ll add(ll a, ll b, ll m = MOD) {
	return a + b < m ? a + b : a + b - m;
}

ll mul(ll a, ll b, ll M = MOD) {
	ll ret = a * b - M * ull(1.L / M * a * b);
	return ret + M * (ret < 0) - M * (ret >= (ll)M);
}

ll bpow(ll b, ll e, ll mod = MOD) {
	ll ans = 1;
	for (; e; b = mul(b, b, mod), e /= 2)
		if (e & 1) ans = mul(ans, b, mod);
	return ans;
}

const ll P_inv = bpow(P, MOD - 2);

ll pw[MAXN];
int n;

void pre() {
	pw[0] = 1;
	
	for (int i = 1; i < MAXN; i++) {
		pw[i] = mul(pw[i - 1], P);
	}
}

map<vector<int>, int> gen(vector<int> A) {
	queue<pair<vector<int>, int>> Q;
	set<pair<vector<int>, int>> S;
	map<pair<vector<int>, int>, int> D;
	map<vector<int>, int> ans;
	
	for (int st = 0; st < n; st++) {
		Q.push({A, st});
		S.insert({A, st});
		D[{A, st}] = 0;
	}
	
	ans[A] = 0;
	
	while (!Q.empty()) {
		vector<int> v = Q.front().first;
		int pos = Q.front().second;
		Q.pop();
		
		if (!ans[v]) {
			ans[v] = D[{v, pos}];
		}
		
		for (int d: {-1, +1}) {
			int new_pos = (pos + d + n) % n;
			vector<int> new_v = v;
			swap(new_v[pos], new_v[new_pos]);
			if (!S.count({new_v, new_pos})) {
				D[{new_v, new_pos}] = D[{v, pos}] + 1;
				S.insert({new_v, new_pos});
				Q.push({new_v, new_pos});
			}
		}
	}
	
	return ans;
}

ll pref[MAXN];

int calc_fast(vector<int> A, vector<int> B) {
	if (A == B) {
		return 0;
	}
	
	vector<pair<ll, int>> M;
	
	for (int i = 0; i < n; i++) {
		vector<int> nB = B;
		rotate(nB.begin(), nB.begin() + i, nB.end());
		ll hsh = 0;
		
		for (int j = 0; j < n; j++) {
			hsh = add(hsh, mul(nB[j], pw[j]));
		}
		
		M.push_back({hsh, (n - i) % n});
	}
	
	sort(M.begin(), M.end());
	vector<int> st_block(M.size()), en_block(M.size());
	
	for (int i = 0; i < M.size(); i++) {
		if (i == 0 || M[i].first != M[i - 1].first) {
			st_block[i] = i;
		}
		else {
			st_block[i] = st_block[i - 1];
		}
	}
	
	for (int i = M.size() - 1; i >= 0; i--) {
		if (i == M.size() - 1 || M[i].first != M[i + 1].first) {
			en_block[i] = i;
		}
		else {
			en_block[i] = en_block[i + 1];
		}
	}
	
	int ans = (int) 1e9;
	
	for (int l = 0; l < n; l++) {
		for (int i = 0; i < n; i++) {
			pref[i] = add(mul(pw[i], A[i]), i > 0 ? pref[i - 1] : 0);
		}
		
		for (int len = 2; len <= n; len++) {
			ll suf_part = add(pref[n - 1], MOD - pref[len-1]);
			ll hsh_A = add(mul(add(pref[len - 1], MOD - pref[0]), P_inv), mul(pref[0], pw[len - 1]));
			ll hsh_B = add(mul(pref[len - 2], P), A[len - 1]);
			
			for (ll h: {hsh_A, hsh_B}) {
				int rot = (n - l) % n;
				ll hsh = add(h, suf_part);				
				int pos = lower_bound(M.begin(), M.end(), make_pair(hsh, rot)) - M.begin();
				
				if (pos < M.size() && M[pos].first == hsh) {
					for (int t: {pos, st_block[pos], en_block[pos]}) {
						int cur = len - 1;
						int pp = M[t].second;
						cur += min(abs(pp - rot), n - abs(pp - rot)) * (n - 1);                             
						ans = min(ans, cur);
					}
				}
				
				if (pos > 0 && M[pos - 1].first == hsh) {
					for (int t: {pos-1, st_block[pos-1], en_block[pos-1]}) {
						int cur = len - 1;
						int pp = M[t].second;
						cur += min(abs(pp - rot), n - abs(pp - rot)) * (n - 1);                             
						ans = min(ans, cur);
					}
				}
			}
		}
		
		rotate(A.begin(), A.begin() + 1, A.end());
	}
	
	return ans == 1e9 ? -1 : ans;
}

int main() {
	pre();
	
	cin >> n;
	vector<int> A(n), B(n);
	
	for (int i = 0; i < n; i++) {
		cin >> A[i];
	}
	
	for (int i = 0; i < n; i++) {
		cin >> B[i];
	}
	
	cout << calc_fast(A, B) << '\n';
	
//	map<vector<int>, int> D = gen(A);
//	
//	vector<int> P(n);
//	iota(P.begin(), P.end(), 1);
//	
//	do {
//		auto it = D.find(P);
//		int ans_slow = (it == D.end() ? -1 : it -> second);
//		int ans_fast = calc_fast(A, P);
//		
//		if (ans_slow != ans_fast) {
//			for (int i = 0; i < n; i++) {
//				cout << P[i] << ' ';
//			}
//			cout << endl;
//			cout << ans_slow << ' ' << ans_fast << endl;
//			exit(0);
//		}
//	}
//	while (next_permutation(P.begin(), P.end()));
	
	return 0;
}