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 Go (1.6) (judge verdict: Time Limit Exceeded)

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
)

var ans int

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	scanner.Scan()
	var n int
	fmt.Sscanf(scanner.Text(), "%d", &n)

	as := make([]int, n)
	for i := 0; i < n; i++ {
		scanner.Scan()
		fmt.Sscanf(scanner.Text(), "%d", &as[i])
	}

	ans := math.MaxInt64
loop:
	for p := 0; p <= n; p++ {
		arr := make([]int, n)
		copy(arr, as)

		count := 0
		// fmt.Println("before", arr)
		if (p-1) >= 0 && arr[p-1] > 0 {
			arr[p-1] = arr[p-1] * (-2)
			count++
		}
		if p < n && arr[p] < 0 {
			arr[p] = arr[p] * (-2)
			count++
		}

		for i := p - 1; i >= 1; i-- {
			if arr[i-1] > arr[i] {
				if arr[i-1] == 0 {
					continue loop
				}
				if arr[i-1] > 0 {
					arr[i-1] = arr[i-1] * (-2)
					count++
				}
				var c int
				arr[i-1], c = negativeMult(arr[i-1], arr[i])
				count = count + c
			}
		}
		for i := p; i <= n-2; i++ {
			if arr[i] > arr[i+1] {
				if arr[i+1] == 0 {
					continue loop
				}
				if arr[i+1] < 0 {
					arr[i+1] = arr[i+1] * (-2)
					count++
				}
				var c int
				arr[i+1], c = positiveMult(arr[i+1], arr[i])
				count = count + c
			}
		}
		// fmt.Println("after ", arr)
		// fmt.Println("count", count)
		// fmt.Println("-------------")
		ans = min(ans, count)
	}
	if ans == math.MaxInt64 {
		fmt.Println(-1)
	} else {
		fmt.Println(ans)
	}

}

func positiveMult(start, cirteria int) (int, int) {
	ret := start
	count := 0
	for ret < cirteria {
		ret = ret * (-2) * (-2)
		count = count + 2
	}
	return ret, count
}

func negativeMult(start, cirteria int) (int, int) {
	ret := start
	count := 0
	for ret > cirteria {
		ret = ret * (-2) * (-2)
		count = count + 2
	}
	return ret, count
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}