#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 1000000001;
const long long LINF = 1000000000000000001LL;
struct info {
  int len;
  int hillIn, hillPref, hillSuff;
  int decrPref, incrSuff;
  long long first, last;
  bool incr() const { return len == incrSuff; }
  bool decr() const { return len == decrPref; }
  bool hill() const { return len == hillPref; }
};
void apply(info &v, long long m) {
  v.first += m;
  v.last += m;
}
long long buff(long long a, long long b) { return a + b; }
info sum(const info &a, const info &b) {
  int hillIn = max(a.hillIn, b.hillIn);
  int hillPref = a.hillPref;
  int hillSuff = b.hillSuff;
  int decrPref = a.decrPref, incrSuff = b.incrSuff;
  if (a.last > b.first) {
    hillIn = max(hillIn, a.hillSuff + b.decrPref);
    if (a.hill()) {
      hillPref += b.decrPref;
    }
    if (a.decr()) {
      decrPref += b.decrPref;
    }
    if (b.decr()) {
      hillSuff += a.hillSuff;
    }
  } else if (a.last < b.first) {
    hillIn = max(hillIn, a.incrSuff + b.hillPref);
    if (b.hill()) {
      hillSuff += a.incrSuff;
    }
    if (b.incr()) {
      incrSuff += a.incrSuff;
    }
    if (a.incr()) {
      hillPref += b.hillPref;
    }
  }
  return {a.len + b.len, hillIn,   hillPref, hillSuff,
          decrPref,      incrSuff, a.first,  b.last};
}
const long long MOD_ZERO = 0;
struct LazyTree {
  int p = 1;
  vector<info> V;
  vector<long long> M;
  LazyTree(vector<int> &a) {
    int n = (int)(a).size();
    p = 1;
    while (p < n) p *= 2;
    int m = 2 * p - 1;
    V.resize(m);
    M.resize(m, MOD_ZERO);
    for (int i = (0); i <= (n - 1); ++i) {
      int v = i + p - 1;
      V[v] = {1, 1, 1, 1, 1, 1, a[i], a[i]};
    }
    for (int i = (p - 2); i >= (0); --i) V[i] = sum(V[2 * i + 1], V[2 * i + 2]);
  }
  void modify(int x, int y, long long m) { _modify(0, 0, p - 1, x, y, m); }
  info query(int x, int y) { return _query(0, 0, p - 1, x, y); }
  void _buff(int u, long long m) { M[u] = buff(M[u], m); }
  void _push(int u) {
    apply(V[u], M[u]);
    if (u < p - 1) {
      _buff(2 * u + 1, M[u]);
      _buff(2 * u + 2, M[u]);
    }
    M[u] = MOD_ZERO;
  }
  void _modify(int u, int a, int b, int x, int y, long long m) {
    _push(u);
    if (x <= a && b <= y) {
      _buff(u, m);
      _push(u);
      return;
    }
    int mid = (a + b) / 2;
    if (x <= mid)
      _modify(2 * u + 1, a, mid, x, y, m);
    else
      _push(2 * u + 1);
    if (mid < y)
      _modify(2 * u + 2, mid + 1, b, x, y, m);
    else
      _push(2 * u + 2);
    V[u] = sum(V[2 * u + 1], V[2 * u + 2]);
  }
  info _query(int u, int a, int b, int x, int y) {
    _push(u);
    if (x <= a && b <= y) {
      return V[u];
    }
    int mid = (a + b) / 2;
    if (y <= mid) {
      return _query(2 * u + 1, a, mid, x, y);
    } else if (mid < x) {
      return _query(2 * u + 2, mid + 1, b, x, y);
    } else {
      return sum(_query(2 * u + 1, a, mid, x, y),
                 _query(2 * u + 2, mid + 1, b, x, y));
    }
  }
};
int main() {
  int n;
  scanf("%d", &n);
  vector<int> a(n);
  for (int i = (0); i <= (n - 1); ++i) {
    scanf("%d", &a[i]);
  }
  LazyTree tree(a);
  int m;
  scanf("%d", &m);
  while (m--) {
    int l, r, d;
    scanf("%d%d%d", &l, &r, &d);
    l--;
    r--;
    tree.modify(l, r, d);
    printf("%d\n", tree.query(0, n - 1).hillIn);
  }
  return 0;
}
