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: Accepted)

#include <algorithm>
#include <climits>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;

long long solveDP1(const vector<long long> &A, vector<long long>& DP1, int i, int shift) {
  int N = A.size();
  if (i >= N)
    return 0;
  if (i == N - 1)
    return shift;
  if (shift >= 40) {
    return solveDP1(A, DP1, i, shift - 2) + (N - i) * 2;
  }
  auto& ret = DP1[i * 40 + shift];
  if (ret >= 0)
    return ret;

  ret = LONG_LONG_MAX;
  long long q0 = A[i];
  long long q = A[i + 1];
  int t = 0;
  while (!(q0 <= q)) {
    q *= 4;
    t += 2;
  }
  while (q0 * 4 <= q) {
    q0 *= 4;
    t -= 2;
  }
  ret = solveDP1(A, DP1, i + 1, max(shift + t, 0)) + shift;
  return ret;
}

long long solve1(const vector<long long> &A) {
  int N = A.size();
  vector<long long> DP1(N * 40, -1);
  vector<long long> revA = A;
  vector<long long> revDP1(N * 40, -1);
  std::reverse(revA.begin(), revA.end());

  long long ans0 = LONG_LONG_MAX;
  for (int i = 0; i <= N; ++i) {
    long long ans = solveDP1(A, DP1, i, 0) + solveDP1(revA, revDP1, N - i, 0) + i;
    ans0 = min(ans, ans0);
  }
  return ans0;
}

int main() {
  int N;
  std::cin >> N;
  vector<long long> A(N);
  for (int i = 0; i < N; ++i) {
    std::cin >> A[i];
  }
  auto ans0 = solve1(A);
  cout << ans0 << endl;
  return 0;
}