Problem:
Score : 300 points

Problem Statement

You are given an integer sequence of length N. The i-th term in the sequence is a_i.
In one operation, you can select a term and either increment or decrement it by one.

At least how many operations are necessary to satisfy the following conditions?

For every i (1≤i≤n), the sum of the terms from the 1-st through i-th term is not zero.

For every i (1≤i≤n-1), the sign of the sum of the terms from the 1-st through i-th term, is different from the sign of the sum of the terms from the 1-st through (i+1)-th term.

Constraints

2 ≤ n ≤ 10^5

|a_i| ≤ 10^9

Each a_i is an integer.

Input

Input is given from Standard Input in the following format:

n
a_1 a_2 ... a_n

Output

Print the minimum necessary count of operations.

Sample Input 1

4
1 -3 1 0

Sample Output 1

4

For example, the given sequence can be transformed into 1, -2, 2, -2 by four operations. The sums of the first one, two, three and four terms are 1, -1, 1 and -1, respectively, which satisfy the conditions.

Sample Input 2

5
3 -6 4 -5 7

Sample Output 2

0

The given sequence already satisfies the conditions.

Sample Input 3

6
-1 4 3 2 -5 4

Sample Output 3

8

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

use std::io;
use std::io::{Read, BufReader};
use std::cmp;

fn next_token<R: Read>(reader: &mut R) -> Vec<u8> {
    let mut buf: [u8; 1] = [0];
    let mut read_chars = false;
    let mut ret: Vec<u8> = vec![];

    loop {
        if reader.read(&mut buf).unwrap() == 0 {
            break;
        } else {
            if buf[0] == '\r' as u8 || buf[0] == '\n' as u8 || buf[0] == ' ' as u8 {
                if read_chars {
                    break;
                }
            } else {
                read_chars = true;
                ret.push(buf[0]);
            }
        }
    };
    ret
}
fn next_i64<R: Read>(reader: &mut R) -> i64 {
    let token = next_token(reader);
    let mut ret: i64 = 0;
    let mut sgn = false;

    for c in token {
        if '0' as u8 <= c && c <= '9' as u8 {
            ret = ret * 10 + (c - ('0' as u8)) as i64;
        } else if '-' as u8 == c {
            sgn = true;
        }
    };
    ret * if sgn { -1 } else { 1 }
}
fn next_i32<R: Read>(reader: &mut R) -> i32 {
    next_i64(reader) as i32
}

fn main() {
    let buf = &mut BufReader::new(io::stdin());

    let n = next_i32(buf);
    let mut a = vec![];
    for _ in 0..n {
        a.push(next_i64(buf));
    }

    let mut ret1 = 0 as i64;
    let mut sum = 0 as i64;
    for i in 0..n {
        sum += a[i as usize];
        if i % 2 == 0 {
            // target: +
            let diff = cmp::max(0, 1 - sum);
            sum += diff;
            ret1 += diff;
        } else {
            // target: -
            let diff = cmp::max(0, sum + 1);
            sum -= diff;
            ret1 += diff;
        }
    //    println!("{} {}", ret1, sum);
    }
    let mut ret2 = 0 as i64;
    let mut sum = 0 as i64;
    for i in 0..n {
        sum += a[i as usize];
        if i % 2 == 1 {
            // target: +
            let diff = cmp::max(0, 1 - sum);
            sum += diff;
            ret2 += diff;
        } else {
            // target: -
            let diff = cmp::max(0, sum + 1);
            sum -= diff;
            ret2 += diff;
        }
    }

    println!("{}", cmp::min(ret1, ret2));
}