#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


constexpr Int INF = 1001001001001001001LL;

int sig(int a) {
  return (a < 0) ? -1 : (a > 0) ? +1 : 0;
}

int N;
vector<int> A;

Int ans;

/*
  - -  0 0 0  + + 
   + +  0 0  - - -
*/
namespace sign {
void run() {
  vector<int> iss[3];
  for (int i = 0; i < N; ++i) {
    const int a = ((i&1)?-1:+1) * A[i];
    iss[sig(a) + 1].push_back(i);
  }
// cerr<<"iss = ";pv(iss,iss+3);
  int lens[3];
  for (int h = 0; h < 3; ++h) {
    lens[h] = iss[h].size();
  }
  
  // relative order in -1's and +1's
  int n = 0;
  vector<int> rel(N, -1);
  for (int i = 0; i < N; ++i) if (A[i] != 0) {
    rel[i] = n++;
  }
  
  vector<Int> head[3], tail[3];
  for (const int h : {0, 2}) {
    head[h].assign(lens[h] + 1, 0);
    tail[h].assign(lens[h] + 1, 0);
    {
      int tar = (h == 0) ? 0 : 1;
      for (int j = 0; j < lens[h]; ++j) {
        head[h][j + 1] = (tar < n) ? (head[h][j] + abs(tar - rel[iss[h][j]])) : INF;
        tar += 2;
      }
    }
    {
      // consider parity later
      int tar = N - 1;
      for (; (tar & 1) != ((h == 0) ? 1 : 0); --tar) {}
      tar -= (N - n);
      for (int j = lens[h]; --j >= 0; ) {
        tail[h][j] = (tar >= 0) ? (abs(tar - rel[iss[h][j]]) + tail[h][j + 1]) : INF;
        tar -= 2;
      }
    }
// cerr<<"-0+"[h]<<": "<<head[h]<<" "<<tail[h]<<endl;
  }
  
  // cost to swap 0's and others
  vector<Int> num0(N + 1, 0);
  for (int i = 0; i < N; ++i) {
    num0[i + 1] = num0[i] + ((A[i] == 0) ? 1 : 0);
  }
  vector<Int> zero(N - lens[1] + 1, 0);
  for (int i = 0; i < N; ++i) if (A[i] != 0) {
    zero[0] += (num0[N] - num0[i]);
  }
  for (int x = 0; x < N - lens[1]; ++x) {
    const int h = (x&1) ? 2 : 0;
    if (x/2 < lens[h]) {
      const int i = iss[h][x/2];
      zero[x + 1] = zero[x] - (num0[N] - num0[i]) + num0[i];
    } else {
      zero[x + 1] = INF;
    }
  }
// cerr<<"zero = "<<zero<<endl;
  
  // 0's to [x, x + lens[1])
  for (int x = 0; x <= N - lens[1]; ++x) {
    const int y = x + lens[1];
    if (x-x/2 <= lens[0] && x/2 <= lens[2] &&
        lens[0] - (x-x/2) == (N/2) - (y/2) && lens[2] - (x/2) == (N-N/2) - (y-y/2)) {
      Int cost = 0;
      cost += head[0][x-x/2] + tail[0][x-x/2];
      cost += head[2][x/2] + tail[2][x/2];
      if (cost >= INF) continue;
      assert(cost % 2 == 0);
      cost /= 2;
      cost += zero[x];
// cerr<<x<<": "<<cost<<endl;
      chmin(ans, cost);
    }
  }
#ifdef LOCAL
Int brt=INF;vector<int>perm(N);for(int i=0;i<N;++i)perm[i]=i;
do{
 vector<int>as(N);
 for(int i=0;i<N;++i){
  as[i]=sig(A[perm[i]]);
  if((i-perm[i])&1)as[i]=-as[i];
 }
 bool ok=true;
 for(int i=0;i<N-1;++i)ok=ok&&(as[i]<=as[i+1]);
 if(ok){
  Int cost=0;
  for(int i=0;i<N;++i)for(int j=i+1;j<N;++j)if(perm[i]>perm[j])++cost;
  chmin(brt,cost);
 }
}while(next_permutation(perm.begin(),perm.end()));
if(brt!=ans)cerr<<"A = "<<A<<": "<<brt<<" "<<ans<<endl;
assert(brt==ans);
#endif
}
}  // sign

int main() {
  for (; ~scanf("%d", &N); ) {
    A.resize(N);
    for (int i = 0; i < N; ++i) {
      scanf("%d", &A[i]);
    }
    
    ans = INF;
    sign::run();
    printf("%lld\n", (ans >= INF / 2) ? -1 : ans);
#ifndef LOCAL
break;
#endif
  }
  return 0;
}