#include <bits/stdc++.h>
using namespace std;
struct node {
  long long lval, rval, add;
  int dlen, ilen, lans, rans, ans, len;
  bool pushed = false;
  node() {}
  node(long long val)
      : rval(val),
        lval(val),
        dlen(1),
        ilen(1),
        lans(1),
        rans(1),
        ans(1),
        len(1),
        add(0) {}
};
node comb(node l, node r) {
  node res;
  res.lval = l.lval + l.add;
  res.rval = r.rval + r.add;
  res.len = l.len + r.len;
  res.add = 0;
  res.ans = max(l.ans, r.ans);
  res.lans = l.lans;
  res.rans = r.rans;
  res.dlen = l.dlen;
  res.ilen = r.ilen;
  if (l.rval + l.add > r.lval + r.add) {
    if (l.dlen == l.len) {
      res.dlen = max(res.dlen, l.dlen + r.dlen);
    }
    if (r.dlen == r.len) {
      res.rans = max(res.rans, r.dlen + l.rans);
    }
    if (l.lans == l.len) {
      res.lans = max(res.lans, l.lans + r.dlen);
    }
    res.ans = max(res.ans, l.rans + r.dlen);
  }
  if (l.rval + l.add < r.lval + r.add) {
    if (r.ilen == r.len) {
      res.ilen = max(res.ilen, r.ilen + l.ilen);
    }
    if (l.ilen == l.len) {
      res.lans = max(res.lans, l.ilen + r.lans);
    }
    if (r.rans == r.len) {
      res.rans = max(res.ans, r.rans + l.ilen);
    }
    res.ans = max(res.ans, r.lans + l.ilen);
  }
  return res;
}
class SegmentTree {
  long long n;
  vector<node> t;
  void push(long long v) {
    if (!t[v].pushed) {
      t[v * 2].add += t[v].add;
      t[v * 2 + 1].add += t[v].add;
      t[v * 2].pushed = t[v * 2 + 1].pushed = false;
      t[v].lval += t[v].add;
      t[v].rval += t[v].add;
      t[v].add = 0;
      t[v].pushed = true;
    }
  }
  void build(long long v, long long tl, long long tr, vector<long long>& a) {
    if (tl == tr) {
      t[v] = node(a[tl]);
    } else {
      long long tm = (tl + tr) / 2;
      build(v * 2, tl, tm, a);
      build(v * 2 + 1, tm + 1, tr, a);
      t[v] = comb(t[v * 2], t[v * 2 + 1]);
    }
  }
  void update(long long v, long long tl, long long tr, long long l, long long r,
              long long d) {
    if (l > r || l < tl || tr < r) return;
    if (tl == l && tr == r) {
      t[v].add += d;
    } else {
      push(v);
      long long tm = (tl + tr) / 2;
      update(v * 2, tl, tm, l, min(r, tm), d);
      update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, d);
      t[v] = comb(t[v * 2], t[v * 2 + 1]);
    }
  }
  node get() { return t[1]; }

 public:
  SegmentTree() {}
  void build(vector<long long>& a) {
    n = a.size();
    t.resize(4 * n);
    build(1, 0, n - 1, a);
  }
  void update(long long l, long long r, long long d) {
    update(1, 0, n - 1, l, r, d);
  }
  node get_ans() { return get(); }
};
SegmentTree st;
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  int n;
  cin >> n;
  vector<long long> a(n);
  for (long long i = 0; i < n; i++) {
    cin >> a[i];
  }
  st.build(a);
  long long q;
  cin >> q;
  for (long long i = 0; i < q; i++) {
    long long l, r, d;
    cin >> l >> r >> d;
    st.update(l - 1, r - 1, d);
    cout << st.get_ans().ans << endl;
  }
  return 0;
}
