Problem:
Score : 700 points

Problem Statement

We have N cards numbered 1, 2, ..., N.
Card i (1 \leq i \leq N) has an integer A_i written in red ink on one side and an integer B_i written in blue ink on the other side.
Initially, these cards are arranged from left to right in the order from Card 1 to Card N, with the red numbers facing up.

Determine whether it is possible to have a non-decreasing sequence facing up from left to right (that is, for each i (1 \leq i \leq N - 1), the integer facing up on the (i+1)-th card from the left is not less than the integer facing up on the i-th card from the left) by repeating the operation below. If the answer is yes, find the minimum number of operations required to achieve it.

Choose an integer i (1 \leq i \leq N - 1).
Swap the i-th and (i+1)-th cards from the left, then flip these two cards.

Constraints

1 \leq N \leq 18

1 \leq A_i, B_i \leq 50 (1 \leq i \leq N)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N
B_1 B_2 ... B_N

Output

If it is impossible to have a non-decreasing sequence, print -1.
If it is possible, print the minimum number of operations required to achieve it.

Sample Input 1

3
3 4 3
3 2 3

Sample Output 1

1

By doing the operation once with i = 1, we have a sequence [2, 3, 3] facing up, which is non-decreasing.

Sample Input 2

2
2 1
1 2

Sample Output 2

-1

After any number of operations, we have the sequence [2, 1] facing up, which is not non-decreasing.

Sample Input 3

4
1 2 3 4
5 6 7 8

Sample Output 3

0

No operation may be required.

Sample Input 4

5
28 15 22 43 31
20 22 43 33 32

Sample Output 4

-1

Sample Input 5

5
4 46 6 38 43
33 15 18 27 37

Sample Output 5

3

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

// #pragma GCC optimize("Ofast","unroll-loops")
// //#pragma GCC push_options
// //#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// #include<bits/stdc++.h>
// #include <xmmintrin.h>
// #include <immintrin.h>
// using namespace::std;
// __attribute__((constructor))void init(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/priority_queue.hpp>
// #include<ext/pb_ds/tag_and_trait.hpp>
// template<typename T>using pbds=__gnu_pbds::tree<T,__gnu_pbds::null_type,less<T>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
// template<typename T>using pbds_map=__gnu_pbds::tree<T,T,less<T>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
// template<typename T,typename E>using hash_map=__gnu_pbds::gp_hash_table<T,E>;
// template<typename T>using pqueue =__gnu_pbds::priority_queue<T, less<T>,__gnu_pbds::rc_binomial_heap_tag>;
// typedef long long lint;
// #define INF (1LL<<60)
// #define IINF (1<<30)
// #define EPS (1e-10)
// #define MOD 1000000007LL
// typedef vector<lint> vec;
// typedef vector<vector<lint>> mat;
// typedef vector<string> svec;
// typedef vector<vector<string>> smat;
// template<typename T>inline void numout(T t){bool f=0;for(auto i:t){cout<<(f?" ":"")<<i<INF/2?i:"INF";f=1;}cout<<endl;}
// template<typename T>inline void numout2(T t){for(auto i:t)numout(i);}
// template<typename T>inline void output(T t){bool f=0;for(auto i:t){cout<<(f?" ":"")<<i;f=1;}cout<<endl;}
// template<typename T>inline void output2(T t){for(auto i:t)output(i);}
// template<typename T>inline void _output(T t){bool f=0;for(lint i=0;i<t.size();i++){cout<<f?"":" "<<t[i];f=1;}cout<<endl;}
// template<typename T>inline void _output2(T t){for(lint i=0;i<t.size();i++)output(t[i]);}
// #define rep(i,n) for(lint i=0;i<lint(n);++i)
// #define repi(i,a,b) for(lint i=lint(a);i<(lint)(b);++i)
// #define rrep(i,n) for(lint i=lint(n)-1;i>=0;--i)
// #define rrepi(i,a,b) for(lint i=lint(b)-1;i>=lint(a);--i)
// #define irep(i) for(lint i=0;;++i)
// #define all(n) begin(n),end(n)
// #define dist(a,b,c,d) sqrt(pow(a-c,2)+pow(b-d,2))
// inline lint gcd(lint A,lint B){return B?gcd(B,A%B):A;}
// inline lint lcm(lint A,lint B){return A/gcd(A,B)*B;}
// inline bool chmin(auto& s,const auto& t){bool res=s>t;s=min(s,t);return res;}
// inline bool chmax(auto& s,const auto& t){bool res=s<t;s=max(s,t);return res;}
// const vector<lint> dx={1,0,-1,0,1,1,-1,-1};
// const vector<lint> dy={0,1,0,-1,1,-1,1,-1};
// #define SUM(v) accumulate(all(v),0LL)
// auto call=[](auto f,auto... args){return f(f,args...);};

// class mint {
//   using u64 = std::uint_fast64_t;
//     public:
//     u64 a;
//     constexpr mint(const u64 x = 0)noexcept:a(x % MOD){}
//     constexpr u64 &value()noexcept{return a;}
//     constexpr const u64 &value() const noexcept {return a;}
//     constexpr mint operator+(const mint rhs)const noexcept{return mint(*this) += rhs;}
//     constexpr mint operator-(const mint rhs)const noexcept{return mint(*this)-=rhs;}
//     constexpr mint operator*(const mint rhs) const noexcept {return mint(*this) *= rhs;}
//     constexpr mint operator/(const mint rhs) const noexcept {return mint(*this) /= rhs;}
//     constexpr mint &operator+=(const mint rhs) noexcept {
//         a += rhs.a;
//         if (a >= MOD)a -= MOD;
//         return *this;
//     }
//     constexpr mint &operator-=(const mint rhs) noexcept {
//         if (a<rhs.a)a += MOD;
//         a -= rhs.a;
//         return *this;
//     }
//     constexpr mint &operator*=(const mint rhs) noexcept {
//         a = a * rhs.a % MOD;
//         return *this;
//     }
//     constexpr mint operator++(int n) const noexcept {
//         return mint(*this) +=1;
//     }
//     constexpr mint operator--(int n) const noexcept {
//         return mint(*this) -=1;
//     }
//     constexpr mint &operator/=(mint rhs) noexcept {
//         u64 exp=MOD-2;
//         while (exp) {
//             if (exp % 2) {
//                 *this *= rhs;
//             }
//             rhs *= rhs;
//             exp /= 2;
//         }
//         return *this;
//     }
//     mint pow(long long n){
//         long long x=a;
//         mint ret = 1;
//         while(n>0) {
//             if(n&1)(ret*=x);
//             (x*=x)%=MOD;
//             n>>=1;
//         }
//         return ret;
//     }
//     mint inv()const{
//         int _a=a,b=MOD,u=1,v=0,t;
//         while(b>0) {
//             t=_a/b;
//             swap(_a-=t*b,b);
//             swap(u-=t*v,v);
//         }
//         return mint(u);
//     }
//     mint comb(lint b){
//         using lint=long long;
//         static bool init=1;
//         static lint fac[1000001],ifac[1000001];
//         if(init){
//             init=0;
//             fac[0]=1;
//             ifac[0]=1;
//             auto mod_pow=[&](lint x,lint n){
//                 lint ans = 1;
//                 while(n != 0){
//                     if(n&1)ans=ans*x%MOD;
//                     x=x*x%MOD;
//                     n=n>>1;
//                 }
//                 return ans;
//             };
//             for(int i=0;i<1000000;i++){
//                 fac[i+1]=fac[i]*(i+1)%MOD;
//                 ifac[i+1]=ifac[i]*mod_pow(i+1, MOD-2)%MOD;
//             }
//         }
//         if(a==0&&b==0)return 1;
//         if((lint)a<b||a<0)return 0;
//         lint tmp=ifac[a-b]*ifac[b]%MOD;
//         return tmp*fac[a]%MOD;
//     }
    
//     friend ostream& operator<<(ostream& lhs, const mint& rhs) noexcept {
//         lhs << rhs.a;
//         return lhs;
//     }
//     friend istream& operator>>(istream& lhs,mint& rhs) noexcept {
//         lhs >> rhs.a;
//         return lhs;
//     }
// };
// inline mint fact(lint a){return a?fact(a-1)*a:1;}

// int main(){
//     lint n;
//     cin>>n;
//     vec a(n),b(n);
//     rep(i,n){
//         cin>>a[i];
//     }
//     rep(i,n)cin>>b[i];
//     lint ans2=INF;
//     rep(i,1<<n){
//         vector<tuple<lint,lint,lint>> v(n);
//         lint tmp=0;
//         rep(j,n){
//             if(i&(1<<j)){
//                 v[j]=make_tuple(a[j],j,0);
//             }else{
//                 tmp++;
//                 v[j]=make_tuple(b[j],j,1);
//             }
//         }
//         sort(all(v));
//         map<lint,lint>mn;
//         map<lint,lint>mx;
//         rep(i,n){
//             chmin(mn[v[j]],j);
//             chmin(mx[v[j]],j);
//         }
//     }
//     if(ans2==INF){
//         cout<<-1<<endl;
//     }
//     else cout<<ans2/2<<endl;
// }
#pragma GCC optimize("Ofast","unroll-loops")
//#pragma GCC push_options
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include<bits/stdc++.h>
#include <xmmintrin.h>
#include <immintrin.h>
using namespace::std;
__attribute__((constructor))void init(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/priority_queue.hpp>
#include<ext/pb_ds/tag_and_trait.hpp>
template<typename T>using pbds=__gnu_pbds::tree<T,__gnu_pbds::null_type,less<T>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
template<typename T>using pbds_map=__gnu_pbds::tree<T,T,less<T>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
template<typename T,typename E>using hash_map=__gnu_pbds::gp_hash_table<T,E>;
template<typename T>using pqueue =__gnu_pbds::priority_queue<T, less<T>,__gnu_pbds::rc_binomial_heap_tag>;
typedef long long lint;
#define INF (1LL<<60)
#define IINF (1<<30)
#define EPS (1e-10)
#define MOD 1000000007LL
typedef vector<lint> vec;
typedef vector<vector<lint>> mat;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
template<typename T>inline void numout(T t){bool f=0;for(auto i:t){cout<<(f?" ":"")<<i<INF/2?i:"INF";f=1;}cout<<endl;}
template<typename T>inline void numout2(T t){for(auto i:t)numout(i);}
template<typename T>inline void output(T t){bool f=0;for(auto i:t){cout<<(f?" ":"")<<i;f=1;}cout<<endl;}
template<typename T>inline void output2(T t){for(auto i:t)output(i);}
template<typename T>inline void _output(T t){bool f=0;for(lint i=0;i<t.size();i++){cout<<f?"":" "<<t[i];f=1;}cout<<endl;}
template<typename T>inline void _output2(T t){for(lint i=0;i<t.size();i++)output(t[i]);}
#define rep(i,n) for(lint i=0;i<lint(n);++i)
#define repi(i,a,b) for(lint i=lint(a);i<(lint)(b);++i)
#define rrep(i,n) for(lint i=lint(n)-1;i>=0;--i)
#define rrepi(i,a,b) for(lint i=lint(b)-1;i>=lint(a);--i)
#define irep(i) for(lint i=0;;++i)
#define all(n) begin(n),end(n)
#define dist(a,b,c,d) sqrt(pow(a-c,2)+pow(b-d,2))
inline lint gcd(lint A,lint B){return B?gcd(B,A%B):A;}
inline lint lcm(lint A,lint B){return A/gcd(A,B)*B;}
inline bool chmin(auto& s,const auto& t){bool res=s>t;s=min(s,t);return res;}
inline bool chmax(auto& s,const auto& t){bool res=s<t;s=max(s,t);return res;}
const vector<lint> dx={1,0,-1,0,1,1,-1,-1};
const vector<lint> dy={0,1,0,-1,1,-1,1,-1};
#define SUM(v) accumulate(all(v),0LL)
auto call=[](auto f,auto... args){return f(f,args...);};

class mint {
  using u64 = std::uint_fast64_t;
    public:
    u64 a;
    constexpr mint(const u64 x = 0)noexcept:a(x % MOD){}
    constexpr u64 &value()noexcept{return a;}
    constexpr const u64 &value() const noexcept {return a;}
    constexpr mint operator+(const mint rhs)const noexcept{return mint(*this) += rhs;}
    constexpr mint operator-(const mint rhs)const noexcept{return mint(*this)-=rhs;}
    constexpr mint operator*(const mint rhs) const noexcept {return mint(*this) *= rhs;}
    constexpr mint operator/(const mint rhs) const noexcept {return mint(*this) /= rhs;}
    constexpr mint &operator+=(const mint rhs) noexcept {
        a += rhs.a;
        if (a >= MOD)a -= MOD;
        return *this;
    }
    constexpr mint &operator-=(const mint rhs) noexcept {
        if (a<rhs.a)a += MOD;
        a -= rhs.a;
        return *this;
    }
    constexpr mint &operator*=(const mint rhs) noexcept {
        a = a * rhs.a % MOD;
        return *this;
    }
    constexpr mint operator++(int n) const noexcept {
        return mint(*this) +=1;
    }
    constexpr mint operator--(int n) const noexcept {
        return mint(*this) -=1;
    }
    constexpr mint &operator/=(mint rhs) noexcept {
        u64 exp=MOD-2;
        while (exp) {
            if (exp % 2) {
                *this *= rhs;
            }
            rhs *= rhs;
            exp /= 2;
        }
        return *this;
    }
    mint pow(long long n){
        long long x=a;
        mint ret = 1;
        while(n>0) {
            if(n&1)(ret*=x);
            (x*=x)%=MOD;
            n>>=1;
        }
        return ret;
    }
    mint inv()const{
        int _a=a,b=MOD,u=1,v=0,t;
        while(b>0) {
            t=_a/b;
            swap(_a-=t*b,b);
            swap(u-=t*v,v);
        }
        return mint(u);
    }
    mint comb(lint b){
        using lint=long long;
        static bool init=1;
        static lint fac[1000001],ifac[1000001];
        if(init){
            init=0;
            fac[0]=1;
            ifac[0]=1;
            auto mod_pow=[&](lint x,lint n){
                lint ans = 1;
                while(n != 0){
                    if(n&1)ans=ans*x%MOD;
                    x=x*x%MOD;
                    n=n>>1;
                }
                return ans;
            };
            for(int i=0;i<1000000;i++){
                fac[i+1]=fac[i]*(i+1)%MOD;
                ifac[i+1]=ifac[i]*mod_pow(i+1, MOD-2)%MOD;
            }
        }
        if(a==0&&b==0)return 1;
        if((lint)a<b||a<0)return 0;
        lint tmp=ifac[a-b]*ifac[b]%MOD;
        return tmp*fac[a]%MOD;
    }
    
    friend ostream& operator<<(ostream& lhs, const mint& rhs) noexcept {
        lhs << rhs.a;
        return lhs;
    }
    friend istream& operator>>(istream& lhs,mint& rhs) noexcept {
        lhs >> rhs.a;
        return lhs;
    }
};
inline mint fact(lint a){return a?fact(a-1)*a:1;}

template<typename T>struct SEG{
    lint n=1;
    vector<T> node;
    T init;
    SEG(lint size,T _init){
        init=_init;
        while(n<size)n*=2;
        node.resize(n*2-1,init);
    }
    void update(lint x,T val){
        x+=(n-1);
        node[x]=func(node[x],val);
        while(x>0){
            x=(x-1)/2;
            node[x]=func(node[x*2+1],node[x*2+2]);
        }
    }
    T get(lint a,lint b,lint k=0,lint l=0,lint r=-1){
        if(r<0)r=n;
        if(r<=a||b<=l)return init;
        if(a<=l&&r<=b)return node[k];
        else{
            T vl=get(a,b,k*2+1,l,(l+r)/2);
            T vr=get(a,b,k*2+2,(l+r)/2,r);
            return func(vl,vr);
        }
    }
    T func(T s,T t){
        return s+t;
    }
};

int main(){
    lint n;
    cin>>n;
    vec a(n),b(n);
    rep(i,n){
        cin>>a[i];
    }
    rep(i,n)cin>>b[i];
    lint ans2=INF;
    rep(i,1<<n){
        vector<tuple<lint,lint,lint>> v(n);
        lint tmp=0;
        rep(j,n){
            if(i&(1<<j)){
                v[j]=make_tuple(a[j],j,0);
            }else{
                tmp++;
                v[j]=make_tuple(b[j],j,1);
            }
        }
        if(tmp%2)continue;
        sort(all(v));
        bool b=1;
        map<lint,vector<lint>>v1;//奇数番
        map<lint,vector<lint>>v2;//奇数番
        map<lint,vector<lint>>v3;//偶数番
        map<lint,vector<lint>>v4;//偶数番
        vector<lint>ans(n);
        rep(j,n){
            if((get<1>(v[j])+get<2>(v[j]))%2){
                v1[get<0>(v[j])].push_back(get<1>(v[j]));
            }else{
                v3[get<0>(v[j])].push_back(get<1>(v[j]));
            }
            if(j%2)v2[get<0>(v[j])].push_back(j);
            else v4[get<0>(v[j])].push_back(j);
        }
        for(auto d:v1){
            if(v1[d.first].size()!=v2[d.first].size()){
                b=0;
                break;
            }else{
                for(int i=0;i<(int)v1[d.first].size();i++){
                    ans[v2[d.first][i]]=v1[d.first][i];
                }
            }
        }
        for(auto d:v3){
            if(v3[d.first].size()!=v4[d.first].size()){
                b=0;
                break;
            }else{
                for(int i=0;i<(int)v3[d.first].size();i++){
                    ans[v4[d.first][i]]=v3[d.first][i];
                }
            }
        }
        if(!b)continue;
        SEG<lint>seg(n,0);
        lint ans3=0;
        rep(i,n){
            ans3+=seg.get(ans[i],n);
            seg.update(ans[i],1);
        }
        chmin(ans2,ans3);
    }
    if(ans2==INF){
        cout<<-1<<endl;
    }
    else cout<<ans2<<endl;
}