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;

        int index;
        int length;
        byte Current => buffer[index];

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

            Step();
        }

        void Step()
        {
            if (++index < length) return;
            index = 0;
            length = stream.Read(buffer, 0, capacity);
        }

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

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

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

            while (!CanInput())
            {
                Step();
            }

            while (CanInput())
            {
                chars.Add((char)Current);
                Step();
            }

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

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

        public long NextLong()
        {
            long ret = 0;
            byte sign = 0;

            while (!IsNumber())
            {
                sign = Current;
                Step();
            }

            while (IsNumber())
            {
                ret = ret * 10 + Current - 48;
                Step();
            }

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

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

            if (Current != 46) return integerPart;

            Step();

            double decimalPart = 0.0, place = 1.0;

            while (IsNumber())
            {
                decimalPart += (Current - 48) * (place /= 10.0);
                Step();
            }

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


Measured memory_bytes: 13012