#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

const int MAXN = 3000;
const int INF = 1e9;

const int MOD = 1e9+7;
struct mint
{
    int x;
    mint() : x(0) {}
    mint(int _x) : x(_x) {}
    mint operator + (int ot) const { return x+ot>=MOD ? x+ot-MOD : x+ot; }
    mint operator - (int ot) const { return x<ot ? x+MOD-ot : x-ot; }
    mint operator - () const { return x ? MOD-x : 0; }
    mint operator * (int ot) const { return 1ll*x*ot%MOD; }
    mint operator += (int ot) { return *this = *this + ot; }
    mint operator -= (int ot) { return *this = *this - ot; }
    mint operator *= (int ot) { return *this = *this * ot; }
    operator int() const { return x; }
};

mint mpow(mint a, ll b)
{
    mint ret=1;
    while(b)
    {
        if(b&1) ret*=a;
        b>>=1; a=a*a;
    }
    return ret;
}
mint inv(mint a) { return mpow(a, MOD-2); }

int N, A[MAXN+10], B[MAXN+10];
mint PP[MAXN+10], IP[MAXN+10];
mint HA[MAXN+10], HB[MAXN+10];
int ans=INF;

void solve()
{
    for(int cyc=0; cyc<N; cyc++)
    {
        vector<pii> V;
        for(int i=1; i<=N; i++) HA[i]=HA[i-1]+PP[i]*mint(A[i]);
        for(int i=1; i<=N; i++) HB[i]=HB[i-1]+PP[i]*mint(B[i]);
        for(int i=1; i<=N; i++) V.push_back({HB[i-1]+(HB[N]-HB[i])*IP[1], i});
        sort(V.begin(), V.end());

        for(int i=2; i<=N; i++)
        {
            mint val = (HA[N]-HA[i-1])*IP[i-1] + (HA[i-1]-HA[1])*PP[N-i];
            auto it=lower_bound(V.begin(), V.end(), pii(val.x, 0));
            if(it!=V.end() && it->first==val.x)
            {
                ans=min(ans, (i-2)*N+it->second-1);
            }
        }

        rotate(A+1, A+2, A+N+1);
        rotate(B+1, B+2, B+N+1);
    }
}

int main()
{
    ios_base::sync_with_stdio(false); cin.tie(NULL);
    
    scanf("%d", &N);
    for(int i=1; i<=N; i++) scanf("%d", &A[i]);
    for(int i=1; i<=N; i++) scanf("%d", &B[i]);

    if(N==1)
    {
        if(A[1]==B[1]) printf("0\n");
        else printf("-1\n");
        return 0;
    }

    PP[0]=1; IP[0]=1;
    PP[1]=29; IP[1]=inv(PP[1]);
    for(int i=2; i<=N; i++) PP[i]=PP[i-1]*PP[1];
    for(int i=2; i<=N; i++) IP[i]=IP[i-1]*IP[1];

    solve();
    reverse(A+1, A+N+1);
    reverse(B+1, B+N+1);
    solve();

    if(ans==INF) printf("-1\n");
    else printf("%d\n", ans);
}