import std.stdio, std.conv, std.string, std.bigint;
import std.math, std.random, std.datetime;
import std.array, std.range, std.algorithm, std.container, std.format;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
/*

まず0の耳がない場合を考える

その場合は、端から端まで歩くとしてよい。各耳に1が入る
そして同じ箇所を往復することにより2ずつ石を入れれるので2で割った余りだけ見ればよい
(a[i] - 1) % 2

1 1 0 0 1 0 0 1 0 1 0 1 
などとなっている

両端から折り返して、どこかからどこかまでをカバーする
そこまでに含まれてしまう0の数と、真ん中に含まれてしまう1の数が、調整しなければならない個数
1 1 0 0 1 0 0 1 0 1 0 1 
~~~     *     ~~*~~~*~~

真ん中に含まれる0の数 - 真ん中に含まれる1の数 が最大になればよい
これは尺取り法でできる

--------------------------------------------------------------------------------

さて0の耳がある場合については…

0の場合にも対応できるように改良する

2をどんどん引いて、0、1、2のいずれかにする
1 1 0 0 1 2 0 1 2 1 2 1

0というのはもともとの0
1というのは先程の言い方でいう0
2というのは先程の言い方でいう1


外れた場合 これを基準とする
0→ペナ0
1→ペナa
2→ペナa

外側に入った場合 p
0→ペナ2 (+2)
1→ペナ1 (-(a-1))
2→ペナ0 (-a)

中央に入った場合 q
0→ペナ1 (+1)
1→ペナ0 (-a)
2→ペナ1 (-(a-1))


点iから始めて、左に行って帰ってくる場合の最良を x[i]
点j - 1から始めて、右に行って帰ってくる場合の最良を y[j]

x[i] = min(x[i - 1] + p[i], 0)
y[j] = min(y[j + 1] + p[j], 0)

点i以左から始めて、点iに帰ってくる場合の最良を x2[i]
点j以右から始めて、点jに帰ってくる場合の最良を y2[i]

x2[i] = min(x[i], x2[i - 1] + q[i]);
y2[i] = min(y[j], y2[j + 1] + q[j]),

求めるものは min(x2[i] + y2[i])

*/


void main(){
	long l = read.to!long;
	
	long[] as;
	foreach(i; 0 .. l) as ~= read.to!long;
	debug writeln("as:", as);
	
	long[] ps, qs;
	foreach(i; 0 .. l){
		long a = as[i];
		if(a == 0) ps~= 2, qs ~= 1;
		else if(a % 2 == 1) ps ~= -(a - 1), qs ~= -a;
		else ps ~= -a, qs ~= -(a - 1);
	}
	debug writeln("ps:", ps);
	debug writeln("qs:", qs);
	
	long[] xs = new long[](l + 1);
	xs[0] = 0;
	foreach(i; 1 .. l + 1) xs[i] = min(xs[i - 1] + ps[i - 1], 0);
	debug writeln("xs:", xs);
	
	long[] ys = new long[](l + 1);
	ys[l] = 0;
	foreach_reverse(i; 0 .. l) ys[i] = min(ys[i + 1] + ps[i], 0);
	debug writeln("ys:", ys);
	
	long[] x2s = new long[](l + 1);
	x2s[0] = xs[0];
	foreach(i; 1 .. l + 1) x2s[i] = min(x2s[i - 1] + qs[i - 1], xs[i]);
	debug writeln("x2s:", x2s);
	
	long[] y2s = new long[](l + 1);
	y2s[l] = ys[l];
	foreach_reverse(i; 0 .. l) y2s[i] = min(y2s[i + 1] + qs[i], ys[i]);
	debug writeln("y2s:", y2s);
	
	long sum;
	foreach(a; as) sum += a;
	debug writeln("sum:", sum);
	
	long ans = sum + 10;
	foreach(i; 0 .. l + 1) ans = min(ans, sum + x2s[i] + y2s[i]);
	
	ans.writeln;
	
}

