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++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <stdio.h>
#include <iostream>
#include <vector>
#include <assert.h>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <stack>
#include <bitset>
#include <string>
#include <sstream>
#include <memory.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>
#include <functional>
#include <algorithm>
using namespace std;
typedef long long ll;
int main()
{
	int n;
	scanf("%d", &n);
	vector<int> v(n + 2);
	for (int i = 1; i <= n; ++i)
		scanf("%d", &v[i]);
	vector<ll> pre(n + 2), suf(n + 2);
	for (int it = 0; it < 2; ++it) {
		vector<ll> s;
		for (int i = 2; i <= n; ++i) {
			ll a = v[i - 1];
			ll b = v[i];
			if (a >= b) {
				pre[i] = pre[i - 1];
				ll times = 0;
				while (a >= b * 4) {
					++times;
					b *= 4;
				}
				s.push_back(times);
			}
			else {
				ll need = 0;
				while (a < b) {
					a *= 4;
					++need;
				}
				ll now = need*(i - 1 - s.size());
				ll cur = need;
				while (!s.empty()) {
					s.back() -= cur;
					if (s.back() == 0) {
						s.pop_back();
						break;
					}
					else if (s.back() < 0) {
						cur = -s.back();
						s.pop_back();
						now += cur;
					}
				}
				pre[i] = pre[i - 1] + now;
			}
		}
		pre.swap(suf);
		reverse(v.begin(), v.end());
	}
	reverse(suf.begin(), suf.end());
	for (int i = 1; i <= n; ++i) {
		pre[i] <<= 1;
		suf[i] <<= 1;
		pre[i] += i;
	}
	ll res = suf[1];
	for (int i = 1; i + 1 <= n; ++i)
		res = min(res, pre[i] + suf[i + 1]);
	printf("%lld\n", res);
	return 0;
}