#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#define rep(i,s,n) for (int i = (int)(s); i < (int)(n); i++)
#define all(v) begin(v),end(v)
using namespace std;
using ll = long long;
bool chmin(auto &a, auto b) { return a > b ? a = b, 1 : 0; }
bool chmax(auto &a, auto b) { return a < b ? a = b, 1 : 0; }

using ull = unsigned long long;
struct roriha {
    static constexpr ull mask30 = (1ULL<<30) - 1;
    static constexpr ull mask31 = (1ULL<<31) - 1;
    static constexpr ull mask61 = (1ULL<<61) - 1;
    static constexpr ull mod = (1ULL<<61) - 1;
    static constexpr ull positive = mod * 4;
    static inline ull base = 0;
    static inline vector<ull> pows = {1};
    static ull mul(ull a, ull b) {
        ull au = a >> 31, ad = a & mask31;
        ull bu = b >> 31, bd = b & mask31;
        ull mid = ad * bu + au * bd;
        ull midu = mid >> 30, midd = mid & mask30;
        return (au * bu * 2 + midu + (midd << 31) + ad * bd);
    }
    static ull cal(ull x) {
        ull xu = x >> 61, xd = x & mask61;
        ull ret = xu + xd;
        if (ret >= mod) ret -= mod;
        return ret;
    }
    static void sethash() {
        if (base == 0) base = (1ULL<<31) + (random_device()() & mask31);
    }
    static void extend(int len) {
        int nlen = pows.size();
        if (nlen > len) return;
        pows.resize(len + 1);
        rep(i, nlen, len + 1) {
            pows[i] = cal(mul(pows[i-1], base));
        }
    }
    vector<ull> inner;
    roriha(vector<int> s = {}) {
        sethash();
        int n = s.size();
        extend(n);
        inner.resize(n + 1);
        inner[0] = 0;
        rep(i,0,n) inner[i+1] = cal(mul(inner[i], base) + s[i]);
    }
    ull get(int l, int r) {
        return cal(inner[r] + positive - mul(inner[l], pows[r-l]));
    }
    static ull concat(ull h1, ull h2, int len2) {
        return cal(cal(mul(h1, pows[len2])) + h2);
    }
};

int main(){
    cin.tie(0)->sync_with_stdio(0);

    int n; cin >> n;
    vector<int> a(n), b(n);
    rep(i,0,n) cin >> a[i];
    rep(i,0,n) cin >> b[i];

    int d = -1;
    rep(i,1,n+1) {
        if (n % i != 0) continue;
        bool mode = 1;
        rep(j,0,n){
            if (b[j] != b[j%i]) mode = 0; 
        }
        if (mode) {
            d = i;
            break;
        }
    }

    unordered_map<ull,int> mp;

    vector<int> b_en(2*n+1);
    rep(i,0,2*n) {
        b_en[i] = b[i % n]; 
    }

    roriha b_roriha = roriha(b_en);
    rep(i,0,d){
        ull targ = b_roriha.get(i, i+n);
        mp[targ] = i;
    }

    vector<int> CNT(1<<21, 0); 
    vector<ull> HASH(1<<21, 0);
    vector<int> VAL(1<<21,-1);
    rep(i,0,d){
        ull targ = b_roriha.get(i, i+n);
        CNT[targ >> 40] += 1;
        HASH[targ >> 40] = targ;
        VAL[targ >> 40] = i;
    }

    int ans = 1e9;

    rep(i,0,n){
        vector<int> a_tmp(n+1);
        int cnt = 1;
        rep(j,0,n){
            if (i == j) continue;
            a_tmp[cnt++] = a[j];
        }    
        a_tmp[n] = a_tmp[1];
        a_tmp[0] = a_tmp[n-1];
        roriha a_roriha = roriha(a_tmp);

        {
            int tar = i;
            int mode = 1;
            rep(j,0,n-1){
                int l = mode;
                int m = mode + tar;
                int r = mode + n-1;
                ull val = a_roriha.concat(a_roriha.get(l, m), a[i], 1);
                val = a_roriha.concat(val, a_roriha.get(m, r), n-1-tar);
                int counts = CNT[val>>40];
                if (counts == 1) {
                    if (HASH[val>>40] == val) {
                        int gogo = VAL[val>>40];
                        int step = j;
                        chmin(ans, step + (n-1) * ((d-gogo)%d) );
                    }
                }else if(counts >= 2) {
                    if (mp.find(val) != mp.end()) {
                        int gogo = mp[val];
                        int step = j;
                        chmin(ans, step + (n-1) * ((d-gogo)%d) );
                    }
                }
                
                tar += 1;
                if (tar >= n){
                    tar = 0;
                    mode += 1;
                }
            }
        }


        {
            int tar = i;
            int mode = 1;
            rep(j,0,n-1){
                int l = mode;
                int m = mode + tar;
                int r = mode + n-1;
                ull val = a_roriha.concat(a_roriha.get(l, m), a[i], 1);
                val = a_roriha.concat(val, a_roriha.get(m, r), n-1-tar);

                int counts = CNT[val>>40];
                if (counts == 1) {
                    if (HASH[val>>40] == val) {
                        int gogo = VAL[val>>40];
                        int step = j;
                        chmin(ans, step + (n-1) * (gogo%d) );
                    }
                }else if(counts >= 2) {
                    if (mp.find(val) != mp.end()) {
                        int gogo = mp[val];
                        int step = j;
                        chmin(ans, step + (n-1) * (gogo%d) );
                    }
                }
                
                tar -= 1;
                if (tar < 0){
                    tar += n;
                    mode -= 1;
                }
            }
        }
    }
    if (ans > 9e8){
        cout << -1 << '\n';
    }else{
        cout << ans << '\n';
    }
}