#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
  x = 0;
  char ch = getchar();
  long long f = 1;
  while (!isdigit(ch)) {
    if (ch == '-') f *= -1;
    ch = getchar();
  }
  while (isdigit(ch)) {
    x = x * 10 + ch - 48;
    ch = getchar();
  }
  x *= f;
}
template <typename T, typename... Args>
void read(T &first, Args &...args) {
  read(first);
  read(args...);
}
template <typename T>
void write(T arg) {
  T x = arg;
  if (x < 0) {
    putchar('-');
    x = -x;
  }
  if (x > 9) {
    write(x / 10);
  }
  putchar(x % 10 + '0');
}
template <typename T, typename... Ts>
void write(T arg, Ts... args) {
  write(arg);
  if (sizeof...(args) != 0) {
    putchar(' ');
    write(args...);
  }
}
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
const int N = 205;
int n;
int dp[N][N][N][2];
int odd, even;
int a[N];
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cin >> n;
  odd = even = n / 2;
  if (n % 2) even++;
  for (int i = 1; i <= n; i++) {
    cin >> a[i];
    if (a[i] != 0) {
      if (a[i] % 2)
        even--;
      else
        odd--;
    }
  }
  int tot = 0;
  memset(dp, 0x3f3f3f3f, sizeof(dp));
  dp[0][0][0][0] = dp[0][0][0][1] = 0;
  for (int i = 1; i <= n; i++) {
    if (a[i]) tot++;
    for (int j = 0; j <= odd; j++) {
      for (int k = 0; k <= even; k++) {
        if (j + k + tot <= i) {
          if (a[i] == 0) {
            dp[i][j][k][0] = min(dp[i - 1][max(0, j - 1)][k][0],
                                 dp[i - 1][max(0, j - 1)][k][1] + 1);
            dp[i][j][k][1] = min(dp[i - 1][j][max(0, k - 1)][0] + 1,
                                 dp[i - 1][j][max(0, k - 1)][1]);
          } else {
            if (a[i] % 2)
              dp[i][j][k][1] = min(dp[i - 1][j][k][1], dp[i - 1][j][k][0] + 1);
            else
              dp[i][j][k][0] = min(dp[i - 1][j][k][1] + 1, dp[i - 1][j][k][0]);
          }
        }
      }
    }
  }
  cout << min(dp[n][odd][even][0], dp[n][odd][even][1]) << endl;
}
