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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.util.*;

public class Main {
	static class Range {
		int size;
		long lv, rv;
		public Range(int size, long lv, long rv) {
			this.size = size;
			this.lv = lv;
			this.rv = rv;
		}
		
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		int N = sc.nextInt();
		long[] A = new long[N];
		for(int i=0; i<N; i++)
			A[i] = sc.nextLong();
		
		int[][] dp = new int[2][];
		
		dp[0] = dp(A);
		long[] B = new long[A.length];
		for(int i=0; i<N; i++)
			B[i] = A[N-1-i];
		dp[1] = dp(B);
		
		int ans = Integer.MAX_VALUE;
		for(int i=0; i<=N; i++)
			ans = Math.min(ans, dp[0][i]+dp[1][N-i]+i);
		
		System.out.println(ans);
		sc.close();
	}
	
	public static int[] dp(long[] A) {
		int N = A.length;
		int[] ans = new int[N+1];
		
		LinkedList<Range> list = new LinkedList<>();
		ans[N] = 0;
		for(int i=N-1; i>=0; i--) {
			ans[i] = ans[i+1];
			list.push(new Range(1, A[i], A[i]));
			
			while(list.size() > 1) {
				Range cur = list.pop();
				if(cur.rv <= list.peek().lv) {
					list.push(cur);
					break;
				}
				Range next = list.pop();
				while(cur.rv > next.lv) {
					next.lv *= 4;
					next.rv *= 4;
					ans[i] += 2*next.size;
				}
				cur.size += next.size;
				cur.rv = next.rv;
				list.push(cur);
			}
		}

		return ans;
	}
	
}