#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);
    }
  }
}
}  // sign


namespace fast {
vector<int> bit;
void bDecr(int pos) {
  for (int x = pos; x < N; x |= x + 1) --bit[x];
}
int bSum(int pos) {
  int ret = 0;
  for (int x = pos; x > 0; x &= x - 1) ret += bit[x - 1];
  return ret;
}

void run() {
  vector<pair<Int, int>> ps(N);
  for (int i = 0; i < N; ++i) {
    ps[i] = make_pair(-abs(A[i]), i);
  }
  sort(ps.begin(), ps.end());
  
  bit.assign(N, 0);
  for (int i = 1; i <= N; ++i) {
    bit[i - 1] = i & -i;
  }
  
  // 0: want +, 1: want -
  Int crt[2][2];
  for (int u = 0; u < 2; ++u) for (int v = 0; v < 2; ++v) {
    crt[u][v] = INF;
  }
  crt[1][(N & 1) ^ 1] = 0;
  auto update = [&](const vector<int> &is) -> void {
    const int len = is.size();
// cerr<<"update is="<<is<<endl;
    vector<int> ss(len);
    for (int j = 0; j < len; ++j) {
      ss[j] = ((A[is[j]] < 0) ? 1 : 0) ^ (is[j] & 1);
    }
    vector<Int> costL(len), costR(len);
    for (int j = 0; j < len; ++j) {
      bDecr(is[j]);
    }
    const int tot = bSum(N);
    for (int j = 0; j < len; ++j) {
      const int res = bSum(is[j]);
      costL[j] = res;
      costR[j] = tot - res;
    }
// cerr<<"  ss = "<<ss<<", costL = "<<costL<<", costR = "<<costR<<endl;
    Int nxt[2][2];
    for (int u = 0; u < 2; ++u) for (int v = 0; v < 2; ++v) {
      nxt[u][v] = INF;
    }
    
    if (len == 1) {
      for (int u = 0; u < 2; ++u) for (int v = 0; v < 2; ++v) {
        if (u == ss[0]) chmin(nxt[u ^ 1][v], crt[u][v] + costL[0]);
        if (v == ss[0]) chmin(nxt[u][v ^ 1], crt[u][v] + costR[0]);
      }
    } else {
      // TODO
      assert(false);
    }
    
    memcpy(crt, nxt, sizeof(nxt));
  };
  for (int j = 0, k = 0; j < N; j = k) {
    for (; k < N && ps[j].first == ps[k].first; ++k) {}
    if (ps[j].first == 0) {
      continue;
    }
    vector<int> is(k - j);
    for (int l = j; l < k; ++l) {
      is[l - j] = ps[l].second;
    }
    update(is);
  }
  
  ans = INF;
  for (int u = 0; u < 2; ++u) for (int v = 0; v < 2; ++v) {
    chmin(ans, crt[u][v]);
  }
}
}  // fast

int main() {
  for (; ~scanf("%d", &N); ) {
    A.resize(N);
    for (int i = 0; i < N; ++i) {
      scanf("%d", &A[i]);
    }
    
    bool isSign = true;
    for (int i = 0; i < N; ++i) isSign = isSign && (abs(A[i]) <= 1);
    
    ans = INF;
    if (isSign) {
      sign::run();
    } else {
      fast::run();
    }
    printf("%lld\n", (ans >= INF) ? -1 : ans);
#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]=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
  }
  return 0;
}