/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author Yulian
 */



#include <iostream>

#include <fstream>
#include <vector>
#include <set>
#include <cmath>
#include <queue>
#include <deque>
#include <string>
#include <algorithm>
#include <map>
#include <numeric>
#include <limits>




#include <ostream>
#include <sstream>


namespace lib {
  template <typename T> int sgn(T val) {
    return (T(0) < val) - (val < T(0));
  }
  //  typedef int querytype;
//
//  template<typename T>
//  std::string to_string(T n) {
//    std::ostringstream stm;
//    stm << n;
//    return stm.str();
//  }
//
//
//  class SegTreeNode {
//  private:
//    // managed index range
//    int l;
//    int r;
//    querytype value;
//    // buffer to store lazy value
//    // to adapt
//    querytype buffer;
//    // left and right child
//    SegTreeNode *left = nullptr;
//    SegTreeNode *right = nullptr;
//    bool lazy = false;
//
//    // adapt basic operation to update a node
//    void update(const querytype &v) {
//      value += v * (r - l + 1);
//    }
//
//  public:
//    SegTreeNode(int l2, int r2, int v, SegTreeNode *left, SegTreeNode *right) : l{l2}, r{r2}, buffer{0},
//                                                                                lazy{false}, left{left}, right{right} {
//      if (left && right) {
//        value = left->getValue() + right->getValue();
//      } else
//        value = v;
//    }
//
//    ~SegTreeNode() {
//      if (left != nullptr) {
//        delete left;
//      }
//      if (right != nullptr) {
//        delete right;
//      }
//    }

//    std::string to_string() const {
//      std::string res = "";
//      if (left) {
//        res += left->to_string() + " ";
//      }
//      res += "(" + lib::to_string(l) + ", " + lib::to_string(r) + "): " + lib::to_string(value);
//      if (right) {
//        res += " " + right->to_string();
//      }
//      return res;
//    }
//
//    int getValue() const {
//      return value;
//    }
//
//    int getL() const {
//      return l;
//    }
//
//    int getR() const {
//      return r;
//    }
//
//    querytype query(int ql, int qr) {
//      querytype res{0};
//      if (l == r) {
//        // leaf
//        res = l >= ql && l <= qr ? value : 0;
//      } else {
//        // inner node
//        if (l >= ql && r <= qr) {
//          // fully contained in requested interval
//          res = value;
//        } else if (r < ql || l > qr) {
//          // not contained at all
//          res = 0;
//        } else {
//          // partially contained
//          if (lazy) {
//            left->propagate(buffer);
//            right->propagate(buffer);
//            lazy = false;
//            buffer = 0;
//          }
//          res = left->query(ql, qr) + right->query(ql, qr);
//        }
//      }
//      return res;
//    }
//
//    void propagate(int val) {
//      buffer += val;
//      lazy = true;
//    }
//
//    void update(int ul, int ur, querytype val) {
//      if (l == r) {
//        if (l >= ul && l <= ur) {
//          // valid leaf
//          update(val);
//        }
//      } else if (l >= ul && r <= ur) {
//        // value can be propagated lazily because current node is fully contained
//        update(val);
//        buffer += val;
//        lazy = true;
//      } else if (r >= ul && l <= ur) {
//        // node contained partially
//        // value must be updated directly because node is not fully contained
//        left->update(ul, ur, val);
//        right->update(ul, ur, val);
//        value = left->getValue() + right->getValue();
//      }
//    }
//  };
//
//
//  std::ostream &operator<<(std::ostream &outs, const SegTreeNode *obj) {
//    return outs << obj->to_string();
//  }
//
//
//  class SegTree {
//  private:
//    SegTreeNode *root;
//    int n;
//    std::allocator<SegTreeNode> al;
//    SegTreeNode *ptr;
//  public:
//    SegTree(std::vector<int> a) {
//      n = a.size();
//      int smoothed = exp2(ceil(log2(n)));
//      ptr = al.allocate(2 * smoothed - 1);
//      for (int i = 0; i < n; ++i) {
//        ptr[smoothed - 1 + i] = SegTreeNode(i, i, a[i], nullptr, nullptr);
//      }
//      for (int i = n; i < smoothed; ++i) {
//        ptr[smoothed - 1 + i] = SegTreeNode(i, i, 0, nullptr, nullptr);
//      }
//      for (int i = smoothed - 2; i >= 0; --i) {
//        ptr[i] = SegTreeNode(ptr[2 * i + 1].getL(), ptr[2 * i + 2].getR(), 0, &ptr[2 * i + 1], &ptr[2 * i + 2]);
//      }
//      root = &ptr[0];
//    }
//
//    ~SegTree() {
//      delete root;
//      al.deallocate(ptr, 2 * exp2(ceil(log2(n))) - 1);
//    }
//
//    std::string to_string() const {
//      return root->to_string();
//    }
//
//    int size() const {
//      return n;
//    }
//
//    querytype query(int ql, int r) {
//      return root->query(ql, std::min(r, n - 1));
//    }
//
//    void update(int l, int r, querytype val) {
//      root->update(l, std::min(r, n - 1), val);
//    }
//  };
//
//  std::ostream &operator<<(std::ostream &outs, const SegTree *obj) {
//    return outs << obj->to_string();
//  }


}


using namespace std;
using namespace lib;

class C {
public:



  void solve(std::istream &in, std::ostream &out) {
    ios::sync_with_stdio(false);
    int n;
    in >> n;
    vector<long long int> a(n), p(n);
    for (int i = 0; i < n; ++i) {
      in >> a[i];
    }
    long long int steps = 0;
    long long int steps2 = 0;

    if (a[0] == 0) {
      p[0] = 1;
      ++steps;
    }else{
      p[0] = a[0];
    }

    for (int i = 0; i < n - 1; ++i) {
      p[i + 1] = p[i] + a[i + 1];
      if (sgn(p[i]) != -sgn(p[i + 1])) {
        steps += abs(p[i + 1]) + 1;
        p[i + 1] = -sgn(p[i]);
      }
    }
    steps2 = abs(a[0]) + 1;
    p[0] = -sgn(p[0]);
    for (int i = 0; i < n - 1; ++i) {
      p[i + 1] = p[i] + a[i + 1];
      if (sgn(p[i]) != -sgn(p[i + 1])) {
        steps2 += abs(p[i + 1]) + 1;
        p[i + 1] = -sgn(p[i]);
      }
    }
    steps = min(steps, steps2);
    out << steps << endl;
  }

};


int main() {
	C solver;
	std::istream& in(std::cin);
	std::ostream& out(std::cout);
	solver.solve(in, out);
	return 0;
}


Measured memory_bytes: 1792