Problem:
Score : 700 points

Problem Statement

There is a sequence X of length N, where every element is initially 0. Let X_i denote the i-th element of X.

You are given a sequence A of length N. The i-th element of A is A_i. Determine if we can make X equal to A by repeating the operation below. If we can, find the minimum number of operations required.

Choose an integer i such that 1\leq i\leq N-1. Replace the value of X_{i+1} with the value of X_i plus 1.

Constraints

1 \leq N \leq 2 \times 10^5

0 \leq A_i \leq 10^9(1\leq i\leq N)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1
:
A_N

Output

If we can make X equal to A by repeating the operation, print the minimum number of operations required. If we cannot, print -1.

Sample Input 1

4
0
1
1
2

Sample Output 1

3

We can make X equal to A as follows:

Choose i=2. X becomes (0,0,1,0).

Choose i=1. X becomes (0,1,1,0).

Choose i=3. X becomes (0,1,1,2).

Sample Input 2

3
1
2
1

Sample Output 2

-1

Sample Input 3

9
0
1
1
0
1
2
2
1
2

Sample Output 3

8

Solution in Rust (1.15.1) (judge verdict: Accepted)

#[allow(unused_macros)]
macro_rules! parse_line {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            iter.next().unwrap().parse::<$t>().unwrap()
        }
    );

    ( $( $t:ty), +) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            ( $(iter.next().unwrap().parse::<$t>().unwrap()),* )
        }
    );
}

#[allow(unused_macros)]
macro_rules! read_line {
    () => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            line.pop();
            line
        }
    )
}

#[allow(unused_macros)]
macro_rules! parse_vec {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let iter = line.split_whitespace();
            iter.map(|v| v.parse::<$t>().unwrap()).collect::<Vec<_>>()
        }
    )
}

fn solve(aa: Vec<i64>) -> i64 {
    use std::cmp::max;

    let n = aa.len();

    let mut last = aa[n-1];

    for mut i in 1..n {
        i = n-i-1;
        if aa[i] + 1 < last {
            return -1
        }

        if last == 0 {
            last = aa[i];
            continue
        }

        last = max(last - 1, aa[i]);
    }

    let mut cnt = 0;
    for mut i in 1..(n+1) {
        i = n-i;
        if i < n - 1 && aa[i]+1 == aa[i+1] {
            continue
        }

        if aa[i] > i as i64 {
            return -1
        }

        cnt += aa[i];
    }

    cnt as i64
}

fn main() {
    let n = parse_line!(usize);
    let mut aa = Vec::new();

    for i in 0..n {
        aa.push(parse_line!(i64));
    }

    println!("{}", solve(aa));
}

#[test]
fn solve_test() {
    assert_eq!(solve(vec![0,1,1,2]), 3);
    assert_eq!(solve(vec![1,2,1]), -1);
    assert_eq!(solve(vec![0,1,1,0,1,2,2,1,2]), 8);
}