Problem:
Score : 600 points

Problem Statement

Snuke stands on a number line. He has L ears, and he will walk along the line continuously under the following conditions:

He never visits a point with coordinate less than 0, or a point with coordinate greater than L.

He starts walking at a point with integer coordinate, and also finishes walking at a point with integer coordinate.

He only changes direction at a point with integer coordinate.

Each time when Snuke passes a point with coordinate i-0.5, where i is an integer, he put a stone in his i-th ear.

After Snuke finishes walking, Ringo will repeat the following operations in some order so that, for each i, Snuke's i-th ear contains A_i stones:

Put a stone in one of Snuke's ears.

Remove a stone from one of Snuke's ears.

Find the minimum number of operations required when Ringo can freely decide how Snuke walks.

Constraints

1 \leq L \leq 2\times 10^5

0 \leq A_i \leq 10^9(1\leq i\leq L)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

L
A_1
:
A_L

Output

Print the minimum number of operations required when Ringo can freely decide how Snuke walks.

Sample Input 1

4
1
0
2
3

Sample Output 1

1

Assume that Snuke walks as follows:

He starts walking at coordinate 3 and finishes walking at coordinate 4, visiting coordinates 3,4,3,2,3,4 in this order.

Then, Snuke's four ears will contain 0,0,2,3 stones, respectively.
Ringo can satisfy the requirement by putting one stone in the first ear.

Sample Input 2

8
2
0
0
2
1
3
4
1

Sample Output 2

3

Sample Input 3

7
314159265
358979323
846264338
327950288
419716939
937510582
0

Sample Output 3

1

Solution in Scala (2.11.7) (judge verdict: Wrong Answer)

object Main {
  def main(args: Array[String]): Unit = {
    val s = new Main()
    s.solve()
    s.out.flush()
  }
}

class Main {
  import java.io._
  import java.util.StringTokenizer

  import scala.collection.mutable
  import scala.util.Sorting
  import math.{abs, max, min}
  import mutable.{ArrayBuffer, ListBuffer}
  import scala.reflect.ClassTag

  val MOD = 1000000007
  val out = new PrintWriter(System.out)

  def solve(): Unit = {
    val N = ni()
    val A = na(N)

    /**
      * (左から詰めたブロックに右から入って出てこない, 右から入って右から出た)
      */
    def calc(A: Array[Int]): (Array[Long], Array[Long]) = {
      val cum = cumSum(A)
      val L_i, L_io = Array.ofDim[Long](N + 1)
      L_i(0) = 0
      L_io(0) = 0

      def cost(i: Int, roundtrip: Boolean, joint: Boolean) = {
        if (joint) {
          if (roundtrip) {
            if (A(i) == 0) 2 else A(i)&1 // 0なら+2、それ以外は奇数なら+1
          } else {
            if (A(i) == 0) 1 else A(i)&1^1// 0なら+1、それ以外は偶数なら+1
          }
        } else {
          if (roundtrip) {
            if (A(i) == 0) 0 else A(i)&1 // 0なら+0、それ以外は奇数なら+1
          } else {
            if (A(i) == 0) 0 else A(i)&1^1// 0なら+0、それ以外は偶数なら+1
          }
        }
      }

      REP(N) { i =>
        {
          val all0 = cum(i + 1) // iも含めて左を全部0にする
          val all0butMe = cum(i) + cost(i, roundtrip = false, joint = false) // 一つ手前までを0にする
          L_i(i + 1) = min(min(all0, all0butMe), L_i(i) + cost(i, roundtrip = false, joint = true))
        }
        {
          val all0 = cum(i + 1) // iも含めて左を全部0にする
          val all0butMe = cum(i) + cost(i, roundtrip = true, joint = false) // 一つ手前までを0にする
          L_io(i + 1) = min(min(all0, all0butMe), L_io(i) + cost(i, roundtrip = true, joint = true))
        }
      }

      (L_i, L_io)
    }

    val (l_i, l_io) = calc(A)
    val (r_i_rev, r_io_rev) = calc(A.reverse)
    val r_i = r_i_rev.reverse
    val r_io = r_io_rev.reverse

//    debug("L_i")
//    debug(l_i)
//    debug("L_io")
//    debug(l_io)
//    debug("R_i")
//    debug(r_i)
//    debug("R_io")
//    debug(r_io)

    // 0-Nで、ここからはじめたらってのを全羅列する
    val ans = map(N + 1) { i =>
      min(l_io(i) + r_i(i), r_io(i) + l_i(i))
    }.min

    out.println(ans)
  }


  def debug(as: Array[Boolean]): Unit = {
    System.err.println(as.map(x => if(x) "1" else "0").mkString)
  }

  def debug(as: Array[Int]): Unit = {
    System.err.println(as.mkString(" "))
  }

  def debug(as: Array[Long]): Unit = {
    System.err.println(as.mkString(" "))
  }

  def debug(s: String): Unit = {
    System.err.println(s)
  }

  def debug(num: Long): Unit = {
    System.err.println(num)
  }

  class InputReader(val stream: InputStream) {
    private val reader = new BufferedReader(new InputStreamReader(stream), 32768)
    private var tokenizer: StringTokenizer = _

    def next(): String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new StringTokenizer(reader.readLine)
      tokenizer.nextToken
    }

    def nextInt(): Int = next().toInt
    def nextLong(): Long = next().toLong
    def nextChar(): Char = next().charAt(0)
  }
  val sc = new InputReader(System.in)
  def ni(): Int = sc.nextInt()
  def nl(): Long = sc.nextLong()
  def nc(): Char = sc.nextChar()
  def ns(): String = sc.next()
  def ns(n: Int): Array[Char] = ns().toCharArray
  def na(n: Int, offset: Int = 0): Array[Int] = map(n)(_ => ni() + offset)
  def na2(n: Int, offset: Int = 0): (Array[Int], Array[Int]) = {
    val A1, A2 = Array.ofDim[Int](n)
    REP(n) { i =>
      A1(i) = ni() + offset
      A2(i) = ni() + offset
    }
    (A1, A2)
  }
  def nm(n: Int, m: Int): Array[Array[Int]] = {
    val A = Array.ofDim[Int](n, m)
    REP(n) { i =>
      REP(m) { j =>
        A(i)(j) = ni()
      }
    }
    A
  }
  def nal(n: Int): Array[Long] = map(n)(_ => nl())
  def nm_c(n: Int, m: Int): Array[Array[Char]] = map(n) (_ => ns(m))
  def REP(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = offset
    val N = n + offset
    while(i < N) { f(i); i += 1 }
  }
  def REP_r(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = n - 1 + offset
    while(i >= offset) { f(i); i -= 1 }
  }

  def map[@specialized A: ClassTag](n: Int, offset: Int = 0)(f: Int => A): Array[A] = {
    val res = Array.ofDim[A](n)
    REP(n)(i => res(i) = f(i + offset))
    res
  }


  def sumL(as: Array[Int]): Long = {
    var s = 0L
    REP(as.length)(i => s += as(i))
    s
  }

  def cumSum(as: Array[Int]) = {
    val cum = Array.ofDim[Long](as.length + 1)
    REP(as.length) { i =>
      cum(i + 1) = cum(i) + as(i)
    }
    cum
  }
}