#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();
  }
  
  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);
    for (int j = 0; j < lens[h]; ++j) {
      const int tar = (h == 0) ? (2 * j) : (2 * j + 1);
      head[h][j + 1] = (tar < N) ? (head[h][j] + abs(tar - iss[h][j])) : INF;
    }
    for (int j = lens[h]; --j >= 0; ) {
      const int tar = (h == 0) ? (2 * (N/2 - (lens[h]-j)) + 1) : (2 * (N-N/2 - (lens[h]-j)));
      tail[h][j] = (tar >= 0) ? (abs(tar - iss[h][j]) + tail[h][j + 1]) : INF;
    }
// cerr<<"-0+"[h]<<": "<<head[h]<<" "<<tail[h]<<endl;
  }
  
  vector<Int> zero(N - lens[1] + 1, 0);
  {
    Int now = 0;
    vector<Int> cnt(N - lens[1] + 1, 0);
    for (int j = 0; j < lens[1]; ++j) {
      // |x+j - iss[1][j]|
      now += (iss[1][j] - j);
      ++cnt[iss[1][j] - j];
    }
    Int slope = -lens[1];
    for (int x = 0; x <= N - lens[1]; ++x) {
      zero[x] = now;
      slope += 2 * cnt[x];
      now += slope;
    }
  }
// 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];
      cost += zero[x];
// cerr<<x<<": "<<cost<<endl;
      assert(cost % 2 == 0);
      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)cost+=abs(i-perm[i]);
  chmin(brt,cost);
 }
}while(next_permutation(perm.begin(),perm.end()));
if(brt!=ans)cerr<<"A = "<<A<<": "<<brt<<" "<<ans<<endl;
assert(brt==ans);
#endif
  ans /= 2;
}
}  // sign

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