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

#include<stdio.h>
#include<stdlib.h>

typedef long long int int64;

int64* calc(const int *a,const int n){
  const int f=16;
  int64 *now=(int64 *)calloc(f,sizeof(int64));
  int64 *next=(int64 *)calloc(f,sizeof(int64));
  int64 *dp=(int64 *)calloc(n,sizeof(int64));
  int i,j;
  for(i=0;i<f;i++) now[i]=2*i;
  dp[n-1]=now[0];
  for(i=n-2;i>=0;i--){
    int64 t=a[i];
    int64 v=a[i+1];
    int k=0;
    for(j=0;j<15;j++,t*=4){
      for(;t>v;k++,v*=4);
      if(k<f){
	next[j]=2*j+now[k];
      } else {
	next[j]=2*j+now[f-1]+2*(k-f+1)*(n-i-1);
      }
    }
    dp[i]=next[0];
    int64 *swap=now;
    now=next;
    next=swap;
  }
  free(now);
  free(next);
  return dp;
}

void run(void){
  int n;
  scanf("%d",&n);
  int *a=(int *)calloc(n,sizeof(int));
  int i;
  for(i=0;i<n;i++) scanf("%d",a+i);
  int64 *dp1=calc(a,n);
  for(i=0;i<n-1-i;i++){
    int swap=a[i];
    a[i]=a[n-1-i];
    a[n-1-i]=swap;
  }
  int64 *dp2=calc(a,n);
  int64 min=dp1[0];
  for(i=1;i<n;i++){
    int64 t=dp1[i]+dp2[n-i]+i;
    if(t<min) min=t;
  }
  printf("%lld\n",min);
  free(a);
  free(dp1);
  free(dp2);
}

int main(void){
  run();
  return 0;
}