using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.CompilerServices;

namespace MinPro2019D
{
    public class Program
    {
        void Solve(SimpleScanner ss, StreamWriter sw)
        {
            //---------------------------------
            var L = ss.NextLong();
            var dp = new long[5];

            for (var i = 0; i < L; i++)
            {
                var A = ss.NextLong();
                var x = A == 0 ? 2 : A & 1;

                dp[0] += A;
                dp[1] += x;
                dp[2] += (x & 1) ^ 1;
                dp[3] += x;
                dp[4] += A;

                for (var t = 1; t < 5; t++)
                {
                    dp[t] = Math.Min(dp[t], dp[t - 1]);
                }
            }

            sw.WriteLine(dp[4]);
            //---------------------------------
        }

        static void Main()
        {
            var ss = new SimpleScanner(Console.OpenStandardInput());
            var sw = new StreamWriter(Console.OpenStandardOutput()) {AutoFlush = false};
            new Program().Solve(ss, sw);
            sw.Flush();
        }
    }

    public class SimpleScanner
    {
        const int DefaultCapacity = 4096;

        readonly Stream stream;
        readonly int capacity;
        readonly byte[] buffer;
        readonly List<char> chars;

        int index;
        int length;
        bool isEof;

        public SimpleScanner(Stream stream, int capacity = DefaultCapacity)
        {
            this.stream = stream;
            this.capacity = capacity;
            this.buffer = new byte[capacity];
            this.chars = new List<char>();

            Reload();
        }

        void Reload()
        {
            index = 0;
            length = stream.Read(buffer, 0, capacity);
            isEof = length == 0;
            if (isEof) buffer[0] = 0;
        }

        byte Peek()
        {
            return buffer[index];
        }

        byte Read()
        {
            var ret = Peek();
            if (++index >= length) Reload();
            return ret;
        }

        bool CanInput()
        {
            return 33 <= Peek() && Peek() <= 126;
        }

        bool IsNumber()
        {
            return 48 <= Peek() && Peek() <= 57;
        }

        public string Next()
        {
            if (isEof) throw new EndOfStreamException();

            chars.Clear();
            while (!CanInput()) Read();
            while (CanInput()) chars.Add((char)Read());
            return new string(chars.ToArray());
        }

        public int NextInt()
        {
            if (isEof) throw new EndOfStreamException();

            return (int)NextLong();
        }

        public long NextLong()
        {
            if (isEof) throw new EndOfStreamException();

            var ret = 0L;
            var isNegative = false;

            while (!IsNumber()) isNegative = Read() == 45;
            while (IsNumber()) ret = ret * 10 + Read() - 48;
            return isNegative ? -ret : ret;
        }

        public double NextDouble()
        {
            if (isEof) throw new EndOfStreamException();

            var integerPart = NextLong();
            if (Peek() == 46) Read();

            double decimalPart = 0.0, place = 1.0;
            while (IsNumber()) decimalPart += (Read() - 48) * (place /= 10.0);
            return integerPart + (integerPart < 0 ? -decimalPart : decimalPart);
        }
    }
}


Measured memory_bytes: 13012