#include <bits/stdc++.h>
using namespace std;
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(string s) { return '"' + s + '"'; }
string to_string(bool f) {
  if (f)
    return "True";
  else
    return "False";
}
string to_string(const char *s) { return to_string((string)s); }
template <typename A>
string to_string(A);
template <typename A, typename B>
string to_string(pair<A, B> p) {
  return "(" + to_string(p.first) + ": " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
  bool f = false;
  string r = "{";
  for (auto x : v) {
    if (f) r += ", ";
    r += to_string(x);
    f = true;
  }
  return r += "}";
}
template <typename A>
string to_string(vector<vector<A>> v) {
  string r;
  for (auto x : v) r += "\n" + to_string(x);
  return r;
}
long long Nerr;
template <typename A>
string to_string(A *p) {
  return to_string(vector<A>(p, p + Nerr));
}
void err(istream_iterator<string>) { cerr << '\n'; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
  cerr << *it << " = " << to_string(a) << "; ";
  err(++it, args...);
}
template <typename T>
void kek(T ans) {
  cout << ans << '\n';
  exit(0);
}
struct data {
  long long mx;
  data() : mx(-(long long)1e15){};
};
struct SegTree {
  long long n;
  vector<data> st;
  vector<bool> cLazy;
  vector<long long> lazy;
  void init(long long a, long long f = -1) {
    n = a;
    if (f != -1) {
      st.resize(4 * n + 5);
      build(1, 0, n, f);
    } else
      st.assign(4 * n + 5, data());
    cLazy.assign(4 * n + 5, false);
    lazy.assign(4 * n + 5, 0);
  }
  void build(long long node, long long tl, long long tr, long long v) {
    st[node].mx = v;
    if (tl == tr) return;
    long long mid = (tl + tr) / 2;
    build(node * 2, tl, mid, v);
    build(node * 2 + 1, mid + 1, tr, v);
  }
  void merge(data &cur, data &l, data &r, long long l1, long long l2) {
    cur.mx = max(l.mx, r.mx);
  }
  void pushdown(long long node, long long L, long long R) {
    if (L != R) {
      cLazy[node * 2] = 1;
      cLazy[node * 2 + 1] = 1;
      lazy[node * 2] += lazy[node];
      lazy[node * 2 + 1] += lazy[node];
    }
    st[node].mx += lazy[node];
    lazy[node] = 0;
    cLazy[node] = 0;
  }
  data Query(long long node, long long tl, long long tr, long long i,
             long long j) {
    if (cLazy[node]) pushdown(node, tl, tr);
    if (j < tl || i > tr) return data();
    if (i <= tl && tr <= j) return st[node];
    long long mid = (tl + tr) / 2;
    data left = Query(node * 2, tl, mid, i, j);
    data right = Query(node * 2 + 1, mid + 1, tr, i, j);
    data cur;
    merge(cur, left, right, mid - tl + 1, tr - mid);
    return cur;
  }
  void Update(long long node, long long tl, long long tr, long long i,
              long long j, long long val) {
    if (cLazy[node]) pushdown(node, tl, tr);
    if (j < tl || i > tr) return;
    if (i <= tl && tr <= j) {
      cLazy[node] = 1;
      lazy[node] = val;
      pushdown(node, tl, tr);
      return;
    }
    long long mid = (tl + tr) / 2;
    Update(node * 2, tl, mid, i, j, val);
    Update(node * 2 + 1, mid + 1, tr, i, j, val);
    merge(st[node], st[node * 2], st[node * 2 + 1], mid - tl + 1, tr - mid);
  }
  data query(long long pos) { return Query(1, 0, n, pos, pos); }
  data query(long long l, long long r) { return Query(1, 0, n, l, r); }
  void update(long long pos, long long val) { Update(1, 0, n, pos, pos, val); }
  void update(long long l, long long r, long long val) {
    Update(1, 0, n, l, r, val);
  }
};
signed main() {
  ios_base::sync_with_stdio(0);
  long long TESTS = 1;
  while (TESTS--) {
    long long n;
    cin >> n;
    vector<long long> a(n + 1);
    for (long long i = 1; i < n + 1; i++) cin >> a[i];
    vector<long long> b(n + 1);
    b[1] = 0;
    SegTree st;
    st.init(n + 1, 0);
    SegTree st2;
    st2.init(n + 1, 0);
    SegTree st3;
    st3.init(n + 1, 0);
    long long sum = 0;
    for (long long i = 2; i < n + 1; i++) {
      if (a[i] > a[i - 1]) sum += a[i] - a[i - 1];
      st.update(i, sum);
    }
    for (long long i = 1; i < n + 1; i++) {
      st2.update(i, a[i] - st.query(i).mx);
      st3.update(i, a[i]);
    }
    long long r1 = st.query(1, n).mx;
    long long r2 = st2.query(1, n).mx;
    long long x1 = (r2 - r1 + 1) / 2;
    long long x2 = (r2 - r1 - 1) / 2;
    cout << min(max(r1 + x1, r2 - x1), max(r1 + x2, r2 - x2)) << '\n';
    long long q;
    cin >> q;
    while (q--) {
      long long l, r, x;
      cin >> l >> r >> x;
      if (l != 1) {
        long long pd = st3.query(l).mx - st3.query(l - 1).mx;
        if (pd >= 0) {
          st.update(l, n, -pd);
          st2.update(l, n, pd);
        }
        long long nd = pd + x;
        if (nd >= 0) {
          st.update(l, n, nd);
          st2.update(l, n, -nd);
        }
      }
      if (r != n) {
        long long pd = st3.query(r + 1).mx - st3.query(r).mx;
        if (pd >= 0) {
          st.update(r + 1, n, -pd);
          st2.update(r + 1, n, pd);
        }
        long long nd = pd - x;
        if (nd >= 0) {
          st.update(r + 1, n, nd);
          st2.update(r + 1, n, -nd);
        }
      }
      st3.update(l, r, x);
      st2.update(l, r, x);
      long long r1 = st.query(1, n).mx;
      long long r2 = st2.query(1, n).mx;
      long long x1 = (r2 - r1 + 1) / 2;
      long long x2 = (r2 - r1 - 1) / 2;
      cout << min(max(r1 + x1, r2 - x1), max(r1 + x2, r2 - x2)) << '\n';
    }
  }
}
