#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);
    assert(N <= 2000);
    vii mem(3);
    rep(i,0,N){
        if(i%2) A[i] = -A[i];
        mem[A[i]+1].pb(i);
    }
    ll ans = inf;
    REP(t,1,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;
        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);
        ll cost = 0;
        rep(i,0,N){
            cost += bit.sum(N)-bit.sum(ord[i]);
            bit.add(ord[i], 1);
        }
        ans = std::min(ans, cost);
    }
    REP(t,0,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;
        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);
        ll cost = 0;
        rep(i,0,N){
            cost += bit.sum(N)-bit.sum(ord[i]);
            bit.add(ord[i], 1);
        }
        ans = std::min(ans, cost);
    }
    if(ans == inf) ans = -1;
    cout << ans << ln;
}