#include <bits/stdc++.h>
#define rep(i, l, r) for(int i = (l); i <= (r); i++)
#define per(i, r, l) for(int i = (r); i >= (l); i--)
#define mem(a, b) memset(a, b, sizeof a)
#define For(i, l, r) for(int i = (l), i##e = (r); i < i##e; i++)
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define SZ(x) int((x).size())

using namespace std;
using ll = long long;

template<class T> inline T& cmin(T& a, const T& b) { if(b < a) a = b; return a; }
template<class T> inline T& cmax(T& a, const T& b) { if(a < b) a = b; return a; }
template<class... Args> void print(Args&&... args) {
    ((cout << args << ' '), ...);
}
template<class... Args> void println(Args&&... args) {
    print(args...), cout << endl;
}

const int N = 5e5 + 8;
const ll inf = 0x3f3f3f3f3f3f3f3f;

int n;
pair<int, int> a[N];
ll dp[N][2];

struct {
    int tot, c[N];
    void add(int i, int v) {
        for(tot += v; i <= n; i += i & -i) c[i] += v;
    }
    int sum(int i) {
        int s = 0;
        for(; i; i &= i - 1) s += c[i];
        return s;
    }
} T1, T2;

int main() {
    cin.tie(0)->sync_with_stdio(0);
    cin >> n;
    rep(i, 1, n) {
        int h;
        cin >> h, a[i] = {i & 1 ? h : -h, i};
    }
    sort(a + 1, a + n + 1, [](auto a, auto b) {
        return abs(a.first) < abs(b.first);
    });
    int l = 1;
    while(l <= n && !a[l].first) T1.add(a[l++].second, 1);
    while(l <= n) {
        vector<int> A[2];
        int r = l;
        while(abs(a[r].first) == abs(a[l].first))
            A[a[r].first > 0].pb(a[r].second), r++;
        sort(all(A[0])), sort(all(A[1]));
        dp[r][0] = dp[r][1] = inf;
        rep(j, 0, 1) {
            bool f[N];
            int cnt = 0, type;
            For(k, 0, r - l) cnt += f[k] = j + l - 1 + k & 1;
            cnt -= SZ(A[1]);
            if(l & 1) {
                if(!cnt) type = 0;
                else if(cnt == (j ? 1 : -1))
                    type = 1, f[0] ^= 1;
                else continue;
            } else if(!cnt) type = 2;
            else continue;
            int seq[N], p[2] = {};
            ll s = 0;
            For(k, 0, r - l) {
                int v = seq[k] = A[f[k]][p[f[k]]++];
                s += T2.tot - T2.sum(v) + T1.tot - T1.sum(v), T2.add(v, 1);
            }
            if(type < 2) {
                if(type) s += T1.sum(seq[0]) * 2 - T1.tot;
                cmin(dp[r][j], dp[l][j ^ type] + s);
                for(int k = type; k + 1 < r - l; k += 2) {
                    s += T1.sum(seq[k]) * 2 - T1.tot;
                    s += T1.sum(seq[k + 1]) * 2 - T1.tot;
                    s += seq[k] < seq[k + 1] ? 1 : -1;
                    cmin(dp[r][j], dp[l][f[k]] + s);
                }
            } else {
                cmin(dp[r][j], dp[l][j] + s);
                For(k, 0, r - l) {
                    s += T1.sum(seq[k]) * 2 - T1.tot;
                    cmin(dp[r][j], dp[l][f[k]] + s);
                }
            }
            For(k, 0, r - l) T2.add(seq[k], -1);
        }
        while(l < r) T1.add(a[l++].second, 1);
    }
    ll ans = dp[n + 1][1];
    cout << (ans == inf ? -1 : ans) << '\n';
}