Problem:
Score : 800 points

Problem Statement

There are N positive integers A_1, A_2, ..., A_N.
Takahashi can perform the following operation on these integers any number of times:

Choose 1 \leq i \leq N and multiply the value of A_i by -2.

Notice that he multiplies it by minus two.

He would like to make A_1 \leq A_2 \leq ... \leq A_N holds.
Find the minimum number of operations required. If it is impossible, print -1.

Constraints

1 \leq N \leq 200000

1 \leq A_i \leq 10^9

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N

Output

Print the answer.

Sample Input 1

4
3 1 4 1

Sample Output 1

3

One possible solution is:

Choose i=4 and multiply the value of A_4 by -2. A_1, A_2, A_3, A_4 are now 3, 1, 4, -2.

Choose i=1 and multiply the value of A_1 by -2. A_1, A_2, A_3, A_4 are now -6, 1, 4, -2.

Choose i=4 and multiply the value of A_4 by -2. A_1, A_2, A_3, A_4 are now -6, 1, 4, 4.

Sample Input 2

5
1 2 3 4 5

Sample Output 2

0

A_1 \leq A_2 \leq ... \leq A_N holds before any operation is performed.

Sample Input 3

8
657312726 129662684 181537270 324043958 468214806 916875077 825989291 319670097

Sample Output 3

7

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

// デバッグ実行：Ctrl+F5

using System;

class Program
{
    static void Main(string[] args)
    {
        String line;
        line = Console.ReadLine();
        int N = int.Parse(line);
        
        line = Console.ReadLine();
        String[] words = line.Split(' ');
        long[] Seisu = new long[N];
        long[] Minus_Seisu = new long[N]; //マイナス方向探索用
        for (int i = 0; i < N; i++)
        {
            Seisu[i] = long.Parse(words[i]);
            Minus_Seisu[i] = long.Parse(words[i]);
        }

        //プラス方向からの探索
        int Plus_Kaisu = 0;
        for(int i = N - 2; i >= 0; i--)
        {
            if (i == 0 && N > 1)
            {
               if (Seisu[i] > Seisu[i+1])
                {
                    Plus_Kaisu += 1;
                }
            }
            else if (Seisu[i+1] < Seisu[i])
            {
                Seisu[i + 1] *= 4;
                Plus_Kaisu += 2;

                for (int j = i + 2; j < N; j++)
                {
                    if (i != N - 2 && Seisu[j] < Seisu[j - 1])
                    {
                        Seisu[j] *= 4;
                        Plus_Kaisu += 2;
                    }
                    else break;
                }
                
                i++;
            }
        }
        // マイナス方向からの探索用
        int Minus_Kaisu = 0;
        for (int i = 0; i < N - 1; i++)
        {
            if (Minus_Seisu[i] > Minus_Seisu[i + 1])
            {
                Minus_Seisu[i] *= -2;
                Minus_Kaisu += 1;
                //if (i != 0 && Minus_Seisu[i] > Minus_Seisu[i - 1])
                //{
                //    for (int j = i - 1; j >= 0; j--)
                //    {
                //        Minus_Seisu[j] *= 4;
                //        Minus_Kaisu += 2;
                //    }
                //}

                for (int j = i; j > 0; j--)
                {
                    if (Minus_Seisu[j] < Minus_Seisu[j - 1])
                    {
                        Minus_Seisu[j - 1] *= -2;
                        Minus_Kaisu += 1;
                        if (Minus_Seisu[j] < Minus_Seisu[j - 1])
                        {
                            Minus_Seisu[j - 1] *= -2;
                            Minus_Kaisu += 1;
                            if (Minus_Seisu[j] < Minus_Seisu[j - 1])
                            {
                                Minus_Seisu[j - 1] *= -2;
                                Minus_Kaisu += 1;
                            }
                        }
                    }
                    else break;
                }
                i--;
            }
        }
        if (Plus_Kaisu < Minus_Kaisu)
        {
            Console.WriteLine(Plus_Kaisu);
        }
        else
        {
            Console.WriteLine(Minus_Kaisu);
        }
    }
}