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.In);
            var sw = new StreamWriter(Console.OpenStandardOutput()) {AutoFlush = false};
            new Program().Solve(ss, sw);
            sw.Flush();
        }
    }

    public class SimpleScanner
    {
        const int DefaultCapacity = 1024;

        readonly TextReader textReader;
        readonly int capacity;
        readonly char[] buffer;
        readonly List<char> chars;

        char last = '\0';
        int index = 0;
        int length = 0;

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

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

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

        bool CheckBuffer()
        {
            if (length <= 0) return false;
            if (index < length) return true;
            Reload();
            return CheckBuffer();
        }

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

        char Peek()
        {
            return CheckBuffer() ? buffer[index] : '\0';
        }

        char Read()
        {
            return CheckBuffer() ? buffer[index++] : '\0';
        }

        bool CanPeekInput()
        {
            var b = Peek();
            return '!' <= b && b <= '~';
        }

        bool IsPeekNumber()
        {
            var b = Peek();
            return '0' <= b && b <= '9';
        }

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

            while (!CanPeekInput())
            {
                if (Read() == '\0') throw new EndOfStreamException();
            }

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

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

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

        public long NextLong()
        {
            long ret = 0, sign = 1;

            while (!IsPeekNumber())
            {
                if (Read() == '\0') throw new EndOfStreamException();
            }

            if (Prev() == '-')
            {
                sign = -1;
            }

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

            return sign * ret;
        }

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

            if (Peek() == '.')
            {
                Read();
            }

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

            double decimalPart = 0.0, place = 1.0;

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

            if (integerPart < 0)
            {
                decimalPart *= -1;
            }

            return integerPart + decimalPart;
        }
    }
}


Measured memory_bytes: 13268