using System;
using System.Collections.Generic;
using System.IO;

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 = 256;

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

        byte last = 0;
        int index = 0;
        int length = 0;

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

            this.length = stream.Read(buffer, 0, capacity);
        }

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

        byte Prev()
        {
            return index == 0 ? last : buffer[index - 1];
        }

        byte Peek()
        {
            if (index >= length) Reload();
            return buffer[index];
        }

        byte Read()
        {
            if (index >= length) Reload();
            return buffer[index++];
        }

        bool CanPeekInput()
        {
            byte b = Peek();
            return 33 <= b && b <= 126;
        }

        bool IsPeekNumber()
        {
            byte b = Peek();
            return 48 <= b && b <= 57;
        }

        public string Next()
        {
            chars.Clear();

            while (!CanPeekInput())
            {
                Read();
            }

            while (CanPeekInput())
            {
                chars.Add((char)Read());
            }

            return new string(chars.ToArray());
        }

        public int NextInt()
        {
            return (int)NextLong();
        }

        public long NextLong()
        {
            long ret = 0;

            while (!IsPeekNumber())
            {
                Read();
            }

            byte sign = Prev();

            while (IsPeekNumber())
            {
                ret = ret * 10 + Read() - 48;
            }

            return sign == 45 ? -ret : ret;
        }

        public double NextDouble()
        {
            long integerPart = NextLong();

            if (Peek() == 46)
            {
                Read();
            }

            if (!IsPeekNumber())
            {
                return integerPart;
            }

            double decimalPart = 0.0, place = 1.0;

            while (IsPeekNumber())
            {
                decimalPart += (Read() - 48) * (place /= 10.0);
            }

            return integerPart + (integerPart < 0 ? -decimalPart : decimalPart);
        }
    }
}


Measured memory_bytes: 13140