using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;

namespace ReadWriteTemplate
{
    public static class Solver
    {
        private static void SolveCase()
        {
            int n = ReadInt();
            long[] a = ReadLongArray();
            long[] c1 = Calc(n, a, 4);
            long[] c2 = Calc(n, a.Reverse().ToArray(), 4);

            long ans = long.MaxValue;
            for (int i = 0; i <= n; i++)
            {
                long sum = 0;
                if (i > 0)
                {
                    sum += (i + 2 * c2[n - i]);
                }
                if (i < n)
                {
                    sum += 2 * c1[i];
                }
                // Writer.WriteLine($"{i} : {sum}");
                ans = Math.Min(ans, sum);
            }

            Writer.WriteLine(ans);
        }

        private static long[] Calc(int n, long[] a, int m)
        {
            // WriteArray(a);
            var b = new int[n];
            for (int i = 1; i < n; i++)
            {
                if (a[i] < a[i - 1])
                {
                    long d = a[i];
                    while (d < a[i - 1])
                    {
                        b[i]++;
                        d *= m;
                    }
                }
                else
                {
                    long d = a[i - 1] * m;
                    while (d <= a[i])
                    {
                        b[i]--;
                        d *= m;
                    }
                }
            }

            var zid = new int[n + 1];
            var zc = new long[n + 1];
            zid[0] = n;
            zc[0] = long.MinValue / 2;
            int z = 0;

            long[] c = new long[n];
            long sum = 0;
            for (int i = n - 1; i >= 1; i--)
            {
                if (b[i] <= 0)
                {
                    c[i - 1] = sum;
                    z++;
                    zid[z] = i;
                    zc[z] = b[i];
                }
                else
                {
                    int j = i;
                    long plus = b[i];
                    while (true)
                    {
                        sum += (zid[z] - j) * plus;
                        zc[z] += plus;
                        if (zc[z] > 0)
                        {
                            plus = zc[z];
                            j = zid[z];
                            z--;
                        }
                        else
                        {
                            break;
                        }
                    }
                    c[i - 1] += sum;
                }
            }

            // WriteArray(b);
            // WriteArray(c);

            return c;
        }

        public static void Solve()
        {
            // var sw = Stopwatch.StartNew();

            SolveCase();

            /*int T = ReadInt();
            for (int i = 0; i < T; i++)
            {
                // Writer.WriteLine("Case {0}:", i + 1);
                // Writer.Write("Case #{0}: ", i + 1);
                SolveCase();
            }*/

            // sw.Stop();
            // Console.WriteLine(sw.ElapsedMilliseconds);
        }

        public static void Main()
        {
            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

#if DEBUG
            // Reader = Console.In; Writer = Console.Out;
            Reader = File.OpenText("input.txt"); Writer = File.CreateText("output.txt");
#else
            Reader = Console.In; Writer = Console.Out;
#endif

            // Solve();
            Thread thread = new Thread(Solve, 64 * 1024 * 1024);
            thread.CurrentCulture = CultureInfo.InvariantCulture;
            thread.Start();
            thread.Join();

            Reader.Close();
            Writer.Close();
        }

        public static IOrderedEnumerable<TSource> OrderByWithShuffle<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            return source.Shuffle().OrderBy(keySelector);
        }

        public static T[] Shuffle<T>(this IEnumerable<T> source)
        {
            T[] result = source.ToArray();
            Random rnd = new Random();
            for (int i = result.Length - 1; i >= 1; i--)
            {
                int k = rnd.Next(i + 1);
                T tmp = result[k];
                result[k] = result[i];
                result[i] = tmp;
            }
            return result;
        }

        #region Read/Write

        private static TextReader Reader;

        private static TextWriter Writer;

        private static Queue<string> CurrentLineTokens = new Queue<string>();

        private static string[] ReadAndSplitLine()
        {
            return Reader.ReadLine().Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
        }

        public static string ReadToken()
        {
            while (CurrentLineTokens.Count == 0)
                CurrentLineTokens = new Queue<string>(ReadAndSplitLine());
            return CurrentLineTokens.Dequeue();
        }

        public static string ReadLine()
        {
            return Reader.ReadLine();
        }

        public static int ReadInt()
        {
            return int.Parse(ReadToken());
        }

        public static long ReadLong()
        {
            return long.Parse(ReadToken());
        }

        public static double ReadDouble()
        {
            return double.Parse(ReadToken(), CultureInfo.InvariantCulture);
        }

        public static int[] ReadIntArray()
        {
            return ReadAndSplitLine().Select(int.Parse).ToArray();
        }

        public static long[] ReadLongArray()
        {
            return ReadAndSplitLine().Select(long.Parse).ToArray();
        }

        public static double[] ReadDoubleArray()
        {
            return ReadAndSplitLine().Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray();
        }

        public static int[][] ReadIntMatrix(int numberOfRows)
        {
            int[][] matrix = new int[numberOfRows][];
            for (int i = 0; i < numberOfRows; i++)
                matrix[i] = ReadIntArray();
            return matrix;
        }

        public static string[] ReadLines(int quantity)
        {
            string[] lines = new string[quantity];
            for (int i = 0; i < quantity; i++)
                lines[i] = Reader.ReadLine().Trim();
            return lines;
        }

        public static void WriteArray<T>(IEnumerable<T> array)
        {
            Writer.WriteLine(string.Join(" ", array));
        }

        #endregion
    }
}


Measured memory_bytes: 44864