#include <iostream>
#include <algorithm>
#include <vector>
#define int long long
using namespace std;
const int inf = 0x7fffffffffff;
struct datum {
    int f0, f1;
    int& operator[](int x) { return x ? f1 : f0; }
    void operator+=(int x) { f0 += x, f1 += x; }
    datum(int a = inf, int b = inf) { f0 = a, f1 = b; }
};
struct F {
    int len;
    int s0, s1;
    int& operator[](int x) { return x ? s1 : s0; }
    datum operator()(datum v) {
        if (len) 
            return datum(v[1] + s0, v[0] + s1);
        else 
            return datum(v[0] + s1, v[1] + s0);
    }
};
F operator*(F a, F b) { return (F) { a.len ^ b.len, a[b.len] + b.s0, a[b.len ^ 1] + b.s1 }; }
datum _max(datum a, datum b) { return datum(min(a[0], b[0]), min(a[1], b[1])); }
struct node {
    F f;
    datum v[2];
    int tg[2];
    int tgv;
};
node operator+(node a, node b) {
    node c;
    c.tg[0] = c.tg[1] = c.tgv = 0;
    c.f = a.f * b.f;
    c.v[0] = _max(a.v[0], a.f(b.v[0]));
    c.v[1] = _max(a.v[1], a.f(b.v[1]));
    return c;
}
struct Segment_Tree {
    node T[1000005];
    void tag(int o, int x, int v) { T[o].tg[x] += v, T[o].v[x] += v; }
    void tagv(int o) { T[o].tgv ^= 1, swap(T[o].v[0], T[o].v[1]), swap(T[o].tg[0], T[o].tg[1]); }
    void pushdown(int o) {
        if (T[o].tgv) {
            tagv(o << 1);
            tagv(o << 1 | 1);
            T[o].tgv = 0;
        }
        if (T[o].tg[0]) {
            tag(o << 1, 0, T[o].tg[0]);
            tag(o << 1 | 1, 0, T[o].tg[0]);
            T[o].tg[0] = 0;
        }
        if (T[o].tg[1]) {
            tag(o << 1, 1, T[o].tg[1]);
            tag(o << 1 | 1, 1, T[o].tg[1]);
            T[o].tg[1] = 0;
        }
    }
    void Set(int o, int l, int r, int x, int y, datum v) {
        if (l == r) {
            T[o].v[y] = v;
            return;
        }
        pushdown(o);
        int mid = (l + r) >> 1;
        if (x <= mid) 
            Set(o << 1, l, mid, x, y, v);
        else 
            Set(o << 1 | 1, mid + 1, r, x, y, v);
        T[o] = T[o << 1] + T[o << 1 | 1];
    }
    void Add(int o, int l, int r, int x, int y) {
        if (l == r) {
            T[o].f.len ^= 1;
            T[o].f[T[o].f.len] += y;
            return;
        }
        pushdown(o);
        int mid = (l + r) >> 1;
        if (x <= mid) 
            Add(o << 1, l, mid, x, y);
        else 
            Add(o << 1 | 1, mid + 1, r, x, y);
        T[o] = T[o << 1] + T[o << 1 | 1];
    }
    void Add(int o, int l, int r, int L, int R, int v) {
        if (L <= l && r <= R) {
            tag(o, 0, v);
            return;
        }
        pushdown(o);
        int mid = (l + r) >> 1;
        if (L <= mid) 
            Add(o << 1, l, mid, L, R, v);
        if (R > mid) 
            Add(o << 1 | 1, mid + 1, r, L, R, v);
        T[o] = T[o << 1] + T[o << 1 | 1];
    }
    void Swap(int o, int l, int r, int L, int R) {
        if (L <= l && r <= R) {
            tagv(o);
            return;
        }
        pushdown(o);
        int mid = (l + r) >> 1;
        if (L <= mid) 
            Swap(o << 1, l, mid, L, R);
        if (R > mid) 
            Swap(o << 1 | 1, mid + 1, r, L, R);
        T[o] = T[o << 1] + T[o << 1 | 1];
    }
    node Query(int o, int l, int r, int L, int R) {
        if (L <= l && r <= R) 
            return T[o];
        pushdown(o);
        int mid = (l + r) >> 1;
        if (R <= mid) 
            return Query(o << 1, l, mid, L, R);
        if (L > mid) 
            return Query(o << 1 | 1, mid + 1, r, L, R);
        return Query(o << 1, l, mid, L, R) + Query(o << 1 | 1, mid + 1, r, L, R);
    }
} seg;
int n;
int a[2000005], b[2000005];
int da[2000005], db[2000005], acnt, bcnt;
int _da[2000005], _db[2000005];
vector<int> vec[2000005];
int asdf(int x) { return (x >= inf ? -1 : x); }
signed main() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i], da[i] = a[i];
    for (int i = 1; i <= n; i++) cin >> b[i], db[i] = b[i];
    sort(da + 1, da + n + 1), acnt = unique(da + 1, da + n + 1) - da - 1;
    sort(db + 1, db + n + 1), bcnt = unique(db + 1, db + n + 1) - db - 1;
    for (int i = 1, t; i <= n; i++) t = a[i], _da[a[i] = lower_bound(da + 1, da + acnt + 1, a[i]) - da] = t;
    for (int i = 1, t; i <= n; i++) t = b[i], _db[b[i] = lower_bound(db + 1, db + bcnt + 1, b[i]) - db] = t;
    for (int i = 1; i <= n; i++) vec[a[i]].emplace_back(b[i]);
    for (int i = 1; i <= bcnt + 1; i++) seg.Set(1, 1, bcnt + 1, i, 0, datum(0, inf));
    vec[0].emplace_back(1);
    for (int i = acnt; i; i--) {
        sort(vec[i].begin(), vec[i].end());
        for (auto v : vec[i]) {
            seg.Add(1, 1, bcnt + 1, 1, v, _da[i]);
            seg.Swap(1, 1, bcnt + 1, 1, v);
            seg.Add(1, 1, bcnt + 1, v, _db[v]);
        } 
        // for (int j = 1; j <= bcnt + 1; j++) {
        //     cout << j << " : ";
        //     cout << asdf(seg.Query(1, 1, bcnt + 1, j, j).v[0][0]) << " ";
        //     cout << asdf(seg.Query(1, 1, bcnt + 1, j, j).v[1][0]) << " ";
        //     cout << asdf(seg.Query(1, 1, bcnt + 1, j, j).v[0][1]) << " ";
        //     cout << asdf(seg.Query(1, 1, bcnt + 1, j, j).v[1][1]) << "\n";
        // }
        sort(vec[i - 1].begin(), vec[i - 1].end());
        for (auto v : vec[i - 1]) {
            node tmp = seg.Query(1, 1, bcnt + 1, v, bcnt + 1);
            seg.Set(1, 1, bcnt + 1, v, 0, tmp.v[0]);
            seg.Set(1, 1, bcnt + 1, v, 1, tmp.v[1]);
        }
        // for (int j = 1; j <= bcnt + 1; j++) {
        //     cout << j << " : ";
        //     cout << asdf(seg.Query(1, 1, bcnt + 1, j, j).v[0][0]) << " ";
        //     cout << asdf(seg.Query(1, 1, bcnt + 1, j, j).v[1][0]) << " ";
        //     cout << asdf(seg.Query(1, 1, bcnt + 1, j, j).v[0][1]) << " ";
        //     cout << asdf(seg.Query(1, 1, bcnt + 1, j, j).v[1][1]) << "\n";
        // }
    }
    node x = seg.Query(1, 1, bcnt + 1, 1, 1);
    cout << min(min(x.v[0][0], x.v[0][1]), min(x.v[1][0], x.v[1][1])) << "\n";
    return 0;
}
/*
7
10 12 19 99 10 8 49
9 14 15 199 11 7 19

3
2 8 9
4 7 10

4
3 5 5 4 
3 4 5 5 
9

4
1 6 6 5 
3 2 8 10 
9

4
1 1 2 1 
2 1 1 1 
2
*/