Problem:
Score : 600 points

Problem Statement

Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.

Notes

A binary tree is a rooted tree such that each vertex has at most two direct children.

A leaf in a binary tree is a vertex with zero children.

The depth of a vertex v in a binary tree is the distance from the tree's root to v. (The root has the depth of 0.)

The depth of a binary tree is the maximum depth of a vertex in the tree.

Constraints

0 \leq N \leq 10^5

0 \leq A_i \leq 10^{8} (0 \leq i \leq N)

A_N \geq 1

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_0 A_1 A_2 \cdots A_N

Output

Print the answer as an integer.

Sample Input 1

3
0 1 1 2

Sample Output 1

7

Below is the tree with the maximum possible number of vertices. It has seven vertices, so we should print 7.

Sample Input 2

4
0 0 1 0 2

Sample Output 2

10

Sample Input 3

2
0 3 1

Sample Output 3

-1

Sample Input 4

1
1 1

Sample Output 4

-1

Sample Input 5

10
0 0 1 1 2 3 5 8 13 21 34

Sample Output 5

264

Solution in Scala (2.13.1) (judge verdict: Wrong Answer)

object methods {
  def solver(): Unit = {
    //val scanner = new java.util.Scanner(System.in)

    //標準入力から変数の決定
    val tempList: Seq[Seq[String]] = {
      for(line <- io.Source.stdin.getLines()) yield {
        line.split(' ').toSeq
      }
    }.toSeq
    val N: Int = tempList(0)(0).toInt
    val dSeq: Seq[String] = tempList(1)

    //存在するかしないかの判定
    val use = underPossibility(dSeq)
    if(!(use(0)(0)<= 1 && use(0)(1) >= 1)) println(-1)
    else {
      val reality = topPossibility(dSeq, use)
      println(reality.sum)
      //println(reality.mkString)
      //println(use.map(_.mkString).mkString(","))
    }

  }

  def underPossibility(dSeq: Seq[String]): Array[Array[Int]] = {
    val N: Int = dSeq.length -1
    val dSeqRev: Seq[Int] = dSeq.reverse.map(_.toInt)
    val possibility: Array[Array[Int]] = Array.fill(N + 1)(Array(0, 0))
    possibility(0) = Array(dSeqRev.head, dSeqRev.head)

    var i: Int = 0
    while(i < N) {
      //最小、最大を求める（round：切り捨て、floor：切り捨て、ceil：切り上げ）
      val lowerLimit: Int = (possibility(i)(0)/2.0).ceil.toInt + dSeqRev(i + 1)
      val upperLimit: Int = possibility(i)(1) + dSeqRev(i + 1)
      possibility(i + 1) = Array(lowerLimit, upperLimit)
      i += 1
    }
    possibility.reverse
  }

  def topPossibility(dSeq: Seq[String], underPossibility: Array[Array[Int]]): Array[Int] = {
    val N: Int = dSeq.length -1

    val reality: Array[Int] = Array.fill(N + 1)(0)
    reality(0) = 1

    var i = 0
    while(i < N){
      val maxReality = (reality(i) - dSeq(i).toInt) * 2
      val realMax = if(maxReality < underPossibility(i+1)(1)) maxReality else underPossibility(i+1)(1)
      reality(i + 1) = realMax
      i += 1
    }
    reality
  }
}

object Main extends App {
  methods.solver()
}