#include <bits/stdc++.h>

using std::cin;
using std::cout;
using std::endl;
using std::vector;
using std::string;
using ll = long long;
using vi = vector<ll>;
using vii = vector<vi>;
using pii = std::pair<ll,ll>;

#define rep(i,j,k) for(ll i=ll(j); i<ll(k); i++)
#define REP(i,j,k) for(ll i=ll(j); i<=ll(k); i++)
#define per(i,j,k) for(ll i=ll(j); i>=ll(k); i--)
#define ln "\n"
#define pb emplace_back
#define mp std::make_pair
#define all(a) a.begin(),a.end()
#define mtp std::make_tuple

constexpr ll inf = (1ll<<60);

template<typename T>
struct segment_tree{
    ll N, valINF;
    vector<T> node;
    segment_tree(int n, T valINF_){
        valINF = valINF_;
        N = 1;
        while(N <= n) N *= 2;
        node.resize(2*N, valINF);
    }
    void update(ll idx, T val){
        idx += N;
        node[idx] = val;
        idx /= 2;
        while(idx){
            node[idx] = compare(node[idx*2], node[idx*2+1]);
            idx /= 2;
        }
    }
    T calc(ll l, ll r){
        T ret = valINF;
        l += N;
        r += N;
        r--;
        while(l < r){
            if(l & 1){
                ret = compare(ret, node[l]);
                l++;
            }
            l /= 2;
            if((r&1) == 0){
                ret = compare(ret, node[r]);
                r--;
            }
            r /= 2;
        }
        if(l == r) ret = compare(ret, node[l]);
        return ret;
    }
    T compare(T l, T r){
        return std::min(l, r);
    }
};

template<typename T>
struct binary_indexed_tree{
    ll N;
    vector<T> node;
    binary_indexed_tree(int n){
        N = n;
        node.resize(N+1);
    }
    void add(ll idx, ll val){
        idx++;
        for(; idx<=N; idx+=(idx&(-idx))){
            node[idx] += val;
        }
    }
    T sum(ll idx){
        idx++;
        T ret = 0;
        for(; 0<idx; idx-=(idx&(-idx))){
            ret += node[idx];
        }
        return ret;
    }
};

int main(){
    cin.tie(nullptr);
    std::ios::sync_with_stdio(false);
    ll N; cin >> N;
    vi A(N);
    rep(i,0,N) cin >> A[i];
    assert(*max_element(all(A)) <= 1);
    assert(*min_element(all(A)) >= -1);
    vii mem(3);
    rep(i,0,N){
        if(i%2) A[i] = -A[i];
        mem[A[i]+1].pb(i);
    }
    ll ans = inf;
    if(!mem[0].empty()){
        ll cost = 0;
        {
            ll t = 1;
            ll now = t+(t-1)+mem[1].size();
            ll r2 = 0, r0 = 0;
            if(now%2 == 0){
                r2 = (N-now+1)/2;
                r0 = (N-now)/2;
            }
            else{
                r2 = (N-now)/2;
                r0 = (N-now+1)/2;
            }
            if(r2+t-1 != mem[2].size()) goto XYZ;
            if(r0+t != mem[0].size()) goto XYZ;
            vi ord(N);
            rep(i,0,t){
                ord[i*2] = mem[0][i];
            }
            rep(i,0,t-1){
                ord[i*2+1] = mem[2][i];
            }
            rep(i,2*t-1,2*t-1+mem[1].size()){
                ord[i] = mem[1][i-(2*t-1)];
            }
            rep(i,2*t-1+mem[1].size(),N){
                if(i%2){
                    ord[i] = mem[0][mem[0].size()-r0];
                    r0--;
                }
                else{
                    ord[i] = mem[2][mem[2].size()-r2];
                    r2--;
                }
            }
            binary_indexed_tree<ll> bit(N+1);
            rep(i,0,N){
                cost += bit.sum(N)-bit.sum(ord[i]);
                bit.add(ord[i], 1);
            }
            ans = std::min(cost, ans);
        }
        REP(t,2,N){
            if(t > mem[0].size()) continue;
            if(t-1 > mem[2].size()) continue;
            ll now = t+(t-1)+mem[1].size();
            ll r2 = 0, r0 = 0;
            if(now%2 == 0){
                r2 = (N-now+1)/2;
                r0 = (N-now)/2;
            }
            else{
                r2 = (N-now)/2;
                r0 = (N-now+1)/2;
            }
            if(r2+t-1 != mem[2].size()) continue;
            if(r0+t != mem[0].size()) continue;
            if(now%2){
                if(mem[2][t-2] > mem[0][t-1]) cost++;
                else cost--;
            }
            {
                ll smaller = std::lower_bound(all(mem[1]), mem[0][t-1])-mem[1].begin();
                cost -= (mem[1].size()-smaller);
                cost += smaller;
            }
            {
                ll smaller = std::lower_bound(all(mem[1]), mem[2][t-2])-mem[1].begin();
                cost -= (mem[1].size()-smaller);
                cost += smaller;
            }
            ans = std::min(ans, cost);
        }
    }
    XYZ:;
    {
        ll cost = 0;
        {
            ll t = 0;
            ll now = t+t+mem[1].size();
            ll r2 = 0, r0 = 0;
            if(now%2 == 0){
                r2 = (N-now+1)/2;
                r0 = (N-now)/2;
            }
            else{
                r2 = (N-now)/2;
                r0 = (N-now+1)/2;
            }
            if(r2+t != mem[2].size()) goto WXY;
            if(r0+t != mem[0].size()) goto WXY;
            vi ord(N);
            rep(i,0,t){
                ord[i*2] = mem[0][i];
            }
            rep(i,0,t){
                ord[i*2+1] = mem[2][i];
            }
            rep(i,2*t,2*t+mem[1].size()){
                ord[i] = mem[1][i-(2*t)];
            }
            rep(i,2*t+mem[1].size(),N){
                if(i%2){
                    ord[i] = mem[0][mem[0].size()-r0];
                    r0--;
                }
                else{
                    ord[i] = mem[2][mem[2].size()-r2];
                    r2--;
                }
            }
            binary_indexed_tree<ll> bit(N+1);
            rep(i,0,N){
                cost += bit.sum(N)-bit.sum(ord[i]);
                bit.add(ord[i], 1);
            }
            ans = std::min(ans, cost);
        }
        REP(t,1,N){
            if(t > mem[0].size()) continue;
            if(t > mem[2].size()) continue;
            ll now = t+t+mem[1].size();
            ll r2 = 0, r0 = 0;
            if(now%2 == 0){
                r2 = (N-now+1)/2;
                r0 = (N-now)/2;
            }
            else{
                r2 = (N-now)/2;
                r0 = (N-now+1)/2;
            }
            if(r2+t != mem[2].size()) continue;
            if(r0+t != mem[0].size()) continue;
            
            if(now%2 == 0){
                if(mem[2][t-1] > mem[0][t-1]) cost--;
                else cost++;
            }
            {
                ll smaller = std::lower_bound(all(mem[1]), mem[0][t-1])-mem[1].begin();
                cost -= (mem[1].size()-smaller);
                cost += smaller;
            }
            {
                ll smaller = std::lower_bound(all(mem[1]), mem[2][t-1])-mem[1].begin();
                cost -= (mem[1].size()-smaller);
                cost += smaller;
            }
            ans = std::min(ans, cost);
        }
    }
    WXY:;
    if(ans == inf) ans = -1;
    cout << ans << ln;
}